git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/dird_conf.h

   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  * Director specific configuration and defines
  30  *
  31  *     Kern Sibbald, Feb MM
  32  *
  33  *    Version $Id$
  34  */
  35
  36 /* NOTE:  #includes at the end of this file */
  37
  38 /*
  39  * Resource codes -- they must be sequential for indexing
  40  */
  41 enum {
  42    R_DIRECTOR = 1001,
  43    R_CLIENT,
  44    R_JOB,
  45    R_STORAGE,
  46    R_CATALOG,
  47    R_SCHEDULE,
  48    R_FILESET,
  49    R_POOL,
  50    R_MSGS,
  51    R_COUNTER,
  52    R_CONSOLE,
  53    R_JOBDEFS,
  54    R_DEVICE,
  55    R_FIRST = R_DIRECTOR,
  56    R_LAST  = R_DEVICE                 /* keep this updated */
  57 };
  58
  59
  60 /*
  61  * Some resource attributes
  62  */
  63 enum {
  64    R_NAME = 1020,
  65    R_ADDRESS,
  66    R_PASSWORD,
  67    R_TYPE,
  68    R_BACKUP
  69 };
  70
  71
  72 /* Used for certain KeyWord tables */
  73 struct s_kw {
  74    const char *name;
  75    int token;
  76 };
  77
  78 /* Job Level keyword structure */
  79 struct s_jl {
  80    const char *level_name;                  /* level keyword */
  81    int  level;                        /* level */
  82    int  job_type;                     /* JobType permitting this level */
  83 };
  84
  85 /* Job Type keyword structure */
  86 struct s_jt {
  87    const char *type_name;
  88    int job_type;
  89 };
  90
  91 /* Definition of the contents of each Resource */
  92 /* Needed for forward references */
  93 class SCHED;
  94 class CLIENT;
  95 class FILESET;
  96 class POOL;
  97 class RUN;
  98 class DEVICE;
  99 class RUNSCRIPT;
 100
 101 /*
 102  *   Director Resource
 103  *
 104  */
 105 class DIRRES {
 106 public:
 107    RES   hdr;
 108    dlist *DIRaddrs;
 109    char *password;                    /* Password for UA access */
 110    char *query_file;                  /* SQL query file */
 111    char *working_directory;           /* WorkingDirectory */
 112    const char *scripts_directory;     /* ScriptsDirectory */
 113    char *pid_directory;               /* PidDirectory */
 114    char *subsys_directory;            /* SubsysDirectory */
 115    MSGS *messages;                    /* Daemon message handler */
 116    uint32_t MaxConcurrentJobs;        /* Max concurrent jobs for whole director */
 117    utime_t FDConnectTimeout;          /* timeout for connect in seconds */
 118    utime_t SDConnectTimeout;          /* timeout in seconds */
 119    char *tls_ca_certfile;             /* TLS CA Certificate File */
 120    char *tls_ca_certdir;              /* TLS CA Certificate Directory */
 121    char *tls_certfile;                /* TLS Server Certificate File */
 122    char *tls_keyfile;                 /* TLS Server Key File */
 123    char *tls_dhfile;                  /* TLS Diffie-Hellman Parameters */
 124    alist *tls_allowed_cns;            /* TLS Allowed Clients */
 125    TLS_CONTEXT *tls_ctx;              /* Shared TLS Context */
 126    bool tls_enable;                   /* Enable TLS */
 127    bool tls_require;                  /* Require TLS */
 128    bool tls_verify_peer;              /* TLS Verify Client Certificate */
 129
 130    /* Methods */
 131    char *name() const;
 132 };
 133
 134 inline char *DIRRES::name() const { return hdr.name; }
 135
 136 /*
 137  * Device Resource
 138  *  This resource is a bit different from the other resources
 139  *  because it is not defined in the Director
 140  *  by DEVICE { ... }, but rather by a "reference" such as
 141  *  DEVICE = xxx; Then when the Director connects to the
 142  *  SD, it requests the information about the device.
 143  */
 144 class DEVICE {
 145 public:
 146    RES hdr;
 147
 148    bool found;                        /* found with SD */
 149    int num_writers;                   /* number of writers */
 150    int max_writers;                   /* = 1 for files */
 151    int reserved;                      /* number of reserves */
 152    int num_drives;                    /* for autochanger */
 153    bool autochanger;                  /* set if device is autochanger */
 154    bool open;                         /* drive open */
 155    bool append;                       /* in append mode */
 156    bool read;                         /* in read mode */
 157    bool labeled;                      /* Volume name valid */
 158    bool offline;                      /* not available */
 159    bool autoselect;                   /* can be selected via autochanger */
 160    uint32_t PoolId;
 161    char ChangerName[MAX_NAME_LENGTH];
 162    char VolumeName[MAX_NAME_LENGTH];
 163    char MediaType[MAX_NAME_LENGTH];
 164
 165    /* Methods */
 166    char *name() const;
 167 };
 168
 169 inline char *DEVICE::name() const { return hdr.name; }
 170
 171 /*
 172  * Console ACL positions
 173  */
 174 enum {
 175    Job_ACL = 0,
 176    Client_ACL,
 177    Storage_ACL,
 178    Schedule_ACL,
 179    Run_ACL,
 180    Pool_ACL,
 181    Command_ACL,
 182    FileSet_ACL,
 183    Catalog_ACL,
 184    Where_ACL,
 185    Num_ACL                            /* keep last */
 186 };
 187
 188 /*
 189  *    Console Resource
 190  */
 191 class CONRES {
 192 public:
 193    RES   hdr;
 194    char *password;                    /* UA server password */
 195    alist *ACL_lists[Num_ACL];         /* pointers to ACLs */
 196    char *tls_ca_certfile;             /* TLS CA Certificate File */
 197    char *tls_ca_certdir;              /* TLS CA Certificate Directory */
 198    char *tls_certfile;                /* TLS Server Certificate File */
 199    char *tls_keyfile;                 /* TLS Server Key File */
 200    char *tls_dhfile;                  /* TLS Diffie-Hellman Parameters */
 201    alist *tls_allowed_cns;            /* TLS Allowed Clients */
 202    TLS_CONTEXT *tls_ctx;              /* Shared TLS Context */
 203    bool tls_enable;                   /* Enable TLS */
 204    bool tls_require;                  /* Require TLS */
 205    bool tls_verify_peer;              /* TLS Verify Client Certificate */
 206
 207    /* Methods */
 208    char *name() const;
 209 };
 210
 211 inline char *CONRES::name() const { return hdr.name; }
 212
 213
 214 /*
 215  *   Catalog Resource
 216  *
 217  */
 218 class CAT {
 219 public:
 220    RES   hdr;
 221
 222    int   db_port;                     /* Port */
 223    char *db_address;                  /* host name for remote access */
 224    char *db_socket;                   /* Socket for local access */
 225    char *db_password;
 226    char *db_user;
 227    char *db_name;
 228    int   mult_db_connections;         /* set if multiple connections wanted */
 229
 230    /* Methods */
 231    char *name() const;
 232 };
 233
 234 inline char *CAT::name() const { return hdr.name; }
 235
 236
 237 /*
 238  *   Client Resource
 239  *
 240  */
 241 class CLIENT {
 242 public:
 243    RES   hdr;
 244
 245    int   FDport;                      /* Where File daemon listens */
 246    utime_t FileRetention;             /* file retention period in seconds */
 247    utime_t JobRetention;              /* job retention period in seconds */
 248    char *address;
 249    char *password;
 250    CAT *catalog;                      /* Catalog resource */
 251    uint32_t MaxConcurrentJobs;        /* Maximume concurrent jobs */
 252    uint32_t NumConcurrentJobs;        /* number of concurrent jobs running */
 253    char *tls_ca_certfile;             /* TLS CA Certificate File */
 254    char *tls_ca_certdir;              /* TLS CA Certificate Directory */
 255    char *tls_certfile;                /* TLS Client Certificate File */
 256    char *tls_keyfile;                 /* TLS Client Key File */
 257    alist *tls_allowed_cns;            /* TLS Allowed Clients */
 258    TLS_CONTEXT *tls_ctx;              /* Shared TLS Context */
 259    bool tls_enable;                   /* Enable TLS */
 260    bool tls_require;                  /* Require TLS */
 261    bool AutoPrune;                    /* Do automatic pruning? */
 262
 263    /* Methods */
 264    char *name() const;
 265 };
 266
 267 inline char *CLIENT::name() const { return hdr.name; }
 268
 269
 270 /*
 271  *   Store Resource
 272  *
 273  */
 274 class STORE {
 275 public:
 276    RES   hdr;
 277
 278    int   SDport;                      /* port where Directors connect */
 279    int   SDDport;                     /* data port for File daemon */
 280    char *address;
 281    char *password;
 282    char *media_type;
 283    alist *device;                     /* Alternate devices for this Storage */
 284    uint32_t MaxConcurrentJobs;        /* Maximume concurrent jobs */
 285    uint32_t NumConcurrentJobs;        /* number of concurrent jobs running */
 286    char *tls_ca_certfile;             /* TLS CA Certificate File */
 287    char *tls_ca_certdir;              /* TLS CA Certificate Directory */
 288    char *tls_certfile;                /* TLS Client Certificate File */
 289    char *tls_keyfile;                 /* TLS Client Key File */
 290    TLS_CONTEXT *tls_ctx;              /* Shared TLS Context */
 291    bool tls_enable;                   /* Enable TLS */
 292    bool tls_require;                  /* Require TLS */
 293    bool enabled;                      /* Set if device is enabled */
 294    bool  autochanger;                 /* set if autochanger */
 295    int64_t StorageId;                 /* Set from Storage DB record */
 296    int  drives;                       /* number of drives in autochanger */
 297
 298    /* Methods */
 299    char *dev_name() const;
 300    char *name() const;
 301 };
 302
 303 inline char *STORE::dev_name() const
 304 {
 305    DEVICE *dev = (DEVICE *)device->first();
 306    return dev->hdr.name;
 307 }
 308
 309 inline char *STORE::name() const { return hdr.name; }
 310
 311 /*
 312  * This is a sort of "unified" store that has both the
 313  *  storage pointer and the text of where the pointer was
 314  *  found.
 315  */
 316 class USTORE {
 317 public:
 318    STORE *store;
 319    POOLMEM *store_source;
 320
 321    /* Methods */
 322    USTORE() { store = NULL; store_source = get_pool_memory(PM_MESSAGE);
 323               *store_source = 0; };
 324    ~USTORE() { destroy(); }
 325    void set_source(const char *where);
 326    void destroy();
 327 };
 328
 329 inline void USTORE::destroy()
 330 {
 331    if (store_source) {
 332       free_pool_memory(store_source);
 333       store_source = NULL;
 334    }
 335 }
 336
 337
 338 inline void USTORE::set_source(const char *where)
 339 {
 340    if (!store_source) {
 341       store_source = get_pool_memory(PM_MESSAGE);
 342    }
 343    pm_strcpy(store_source, where);
 344 }
 345
 346
 347 /*
 348  *   Job Resource
 349  */
 350 class JOB {
 351 public:
 352    RES   hdr;
 353
 354    int   JobType;                     /* job type (backup, verify, restore */
 355    int   JobLevel;                    /* default backup/verify level */
 356    int   Priority;                    /* Job priority */
 357    int   RestoreJobId;                /* What -- JobId to restore */
 358    char *RestoreWhere;                /* Where on disk to restore -- directory */
 359    char *strip_prefix;                /* remove prefix from filename  */
 360    char *add_prefix;                  /* add prefix to filename  */
 361    char *add_suffix;                  /* add suffix to filename -- .old */
 362    bool  where_use_regexp;            /* true if RestoreWhere is a BREGEXP */
 363    char *RestoreBootstrap;            /* Bootstrap file */
 364    alist *RunScripts;                 /* Run {client} program {after|before} Job */
 365    union {
 366       char *WriteBootstrap;           /* Where to write bootstrap Job updates */
 367       char *WriteVerifyList;          /* List of changed files */
 368    };
 369    int   replace;                     /* How (overwrite, ..) */
 370    utime_t MaxRunTime;                /* max run time in seconds */
 371    utime_t MaxWaitTime;               /* max blocking time in seconds */
 372    utime_t FullMaxWaitTime;           /* Max Full job wait time */
 373    utime_t DiffMaxWaitTime;           /* Max Differential job wait time */
 374    utime_t IncMaxWaitTime;            /* Max Incremental job wait time */
 375    utime_t MaxStartDelay;             /* max start delay in seconds */
 376    utime_t RescheduleInterval;        /* Reschedule interval */
 377    utime_t JobRetention;              /* job retention period in seconds */
 378    uint32_t MaxConcurrentJobs;        /* Maximum concurrent jobs */
 379    int RescheduleTimes;               /* Number of times to reschedule job */
 380    bool RescheduleOnError;            /* Set to reschedule on error */
 381    bool PrefixLinks;                  /* prefix soft links with Where path */
 382    bool PruneJobs;                    /* Force pruning of Jobs */
 383    bool PruneFiles;                   /* Force pruning of Files */
 384    bool PruneVolumes;                 /* Force pruning of Volumes */
 385    bool SpoolAttributes;              /* Set to spool attributes in SD */
 386    bool spool_data;                   /* Set to spool data in SD */
 387    bool rerun_failed_levels;          /* Upgrade to rerun failed levels */
 388    bool PreferMountedVolumes;         /* Prefer vols mounted rather than new one */
 389    bool write_part_after_job;         /* Set to write part after job in SD */
 390    bool enabled;                      /* Set if job enabled */
 391
 392    MSGS      *messages;               /* How and where to send messages */
 393    SCHED     *schedule;               /* When -- Automatic schedule */
 394    CLIENT    *client;                 /* Who to backup */
 395    FILESET   *fileset;                /* What to backup -- Fileset */
 396    alist     *storage;                /* Where is device -- list of Storage to be used */
 397    POOL      *pool;                   /* Where is media -- Media Pool */
 398    POOL      *full_pool;              /* Pool for Full backups */
 399    POOL      *inc_pool;               /* Pool for Incremental backups */
 400    POOL      *diff_pool;              /* Pool for Differental backups */
 401    char      *selection_pattern;
 402    int        selection_type;
 403    union {
 404       JOB       *verify_job;          /* Job name to verify */
 405    };
 406    JOB       *jobdefs;                /* Job defaults */
 407    alist     *run_cmds;               /* Run commands */
 408    uint32_t NumConcurrentJobs;        /* number of concurrent jobs running */
 409
 410    /* Methods */
 411    char *name() const;
 412 };
 413
 414 inline char *JOB::name() const { return hdr.name; }
 415
 416 #undef  MAX_FOPTS
 417 #define MAX_FOPTS 34
 418
 419 /* File options structure */
 420 struct FOPTS {
 421    char opts[MAX_FOPTS];              /* options string */
 422    alist regex;                       /* regex string(s) */
 423    alist regexdir;                    /* regex string(s) for directories */
 424    alist regexfile;                   /* regex string(s) for files */
 425    alist wild;                        /* wild card strings */
 426    alist wilddir;                     /* wild card strings for directories */
 427    alist wildfile;                    /* wild card strings for files */
 428    alist wildbase;                    /* wild card strings for files without '/' */
 429    alist base;                        /* list of base names */
 430    alist fstype;                      /* file system type limitation */
 431    alist drivetype;                   /* drive type limitation */
 432    char *reader;                      /* reader program */
 433    char *writer;                      /* writer program */
 434 };
 435
 436
 437 /* This is either an include item or an exclude item */
 438 struct INCEXE {
 439    FOPTS *current_opts;               /* points to current options structure */
 440    FOPTS **opts_list;                 /* options list */
 441    int num_opts;                      /* number of options items */
 442    alist name_list;                   /* filename list -- holds char * */
 443 };
 444
 445 /*
 446  *   FileSet Resource
 447  *
 448  */
 449 class FILESET {
 450 public:
 451    RES   hdr;
 452
 453    bool new_include;                  /* Set if new include used */
 454    INCEXE **include_items;            /* array of incexe structures */
 455    int num_includes;                  /* number in array */
 456    INCEXE **exclude_items;
 457    int num_excludes;
 458    bool have_MD5;                     /* set if MD5 initialized */
 459    struct MD5Context md5c;            /* MD5 of include/exclude */
 460    char MD5[30];                      /* base 64 representation of MD5 */
 461    bool ignore_fs_changes;            /* Don't force Full if FS changed */
 462    bool enable_vss;                   /* Enable Volume Shadow Copy */
 463
 464    /* Methods */
 465    char *name() const;
 466 };
 467
 468 inline char *FILESET::name() const { return hdr.name; }
 469
 470 /*
 471  *   Schedule Resource
 472  *
 473  */
 474 class SCHED {
 475 public:
 476    RES   hdr;
 477
 478    RUN *run;
 479 };
 480
 481 /*
 482  *   Counter Resource
 483  */
 484 class COUNTER {
 485 public:
 486    RES   hdr;
 487
 488    int32_t  MinValue;                 /* Minimum value */
 489    int32_t  MaxValue;                 /* Maximum value */
 490    int32_t  CurrentValue;             /* Current value */
 491    COUNTER *WrapCounter;              /* Wrap counter name */
 492    CAT     *Catalog;                  /* Where to store */
 493    bool     created;                  /* Created in DB */
 494    /* Methods */
 495    char *name() const;
 496 };
 497
 498 inline char *COUNTER::name() const { return hdr.name; }
 499
 500 /*
 501  *   Pool Resource
 502  *
 503  */
 504 class POOL {
 505 public:
 506    RES   hdr;
 507
 508    char *pool_type;                   /* Pool type */
 509    char *label_format;                /* Label format string */
 510    char *cleaning_prefix;             /* Cleaning label prefix */
 511    int32_t LabelType;                 /* Bacula/ANSI/IBM label type */
 512    uint32_t max_volumes;              /* max number of volumes */
 513    utime_t VolRetention;              /* volume retention period in seconds */
 514    utime_t VolUseDuration;            /* duration volume can be used */
 515    uint32_t MaxVolJobs;               /* Maximum jobs on the Volume */
 516    uint32_t MaxVolFiles;              /* Maximum files on the Volume */
 517    uint64_t MaxVolBytes;              /* Maximum bytes on the Volume */
 518    utime_t MigrationTime;             /* Time to migrate to next pool */
 519    uint64_t MigrationHighBytes;       /* When migration starts */
 520    uint64_t MigrationLowBytes;        /* When migration stops */
 521    POOL  *NextPool;                   /* Next pool for migration */
 522    alist *storage;                    /* Where is device -- list of Storage to be used */
 523    bool  use_catalog;                 /* maintain catalog for media */
 524    bool  catalog_files;               /* maintain file entries in catalog */
 525    bool  use_volume_once;             /* write on volume only once */
 526    bool  purge_oldest_volume;         /* purge oldest volume */
 527    bool  recycle_oldest_volume;       /* attempt to recycle oldest volume */
 528    bool  recycle_current_volume;      /* attempt recycle of current volume */
 529    bool  AutoPrune;                   /* default for pool auto prune */
 530    bool  Recycle;                     /* default for media recycle yes/no */
 531    POOL  *RecyclePool;                /* RecyclePool destination when media is purged */
 532    /* Methods */
 533    char *name() const;
 534 };
 535
 536 inline char *POOL::name() const { return hdr.name; }
 537
 538
 539
 540
 541 /* Define the Union of all the above
 542  * resource structure definitions.
 543  */
 544 union URES {
 545    DIRRES     res_dir;
 546    CONRES     res_con;
 547    CLIENT     res_client;
 548    STORE      res_store;
 549    CAT        res_cat;
 550    JOB        res_job;
 551    FILESET    res_fs;
 552    SCHED      res_sch;
 553    POOL       res_pool;
 554    MSGS       res_msgs;
 555    COUNTER    res_counter;
 556    DEVICE     res_dev;
 557    RES        hdr;
 558    RUNSCRIPT  res_runscript;
 559 };
 560
 561
 562
 563 /* Run structure contained in Schedule Resource */
 564 class RUN {
 565 public:
 566    RUN *next;                         /* points to next run record */
 567    int level;                         /* level override */
 568    int Priority;                      /* priority override */
 569    int job_type;
 570    bool spool_data;                   /* Data spooling override */
 571    bool spool_data_set;               /* Data spooling override given */
 572    bool write_part_after_job;         /* Write part after job override */
 573    bool write_part_after_job_set;     /* Write part after job override given */
 574
 575    POOL *pool;                        /* Pool override */
 576    POOL *full_pool;                   /* Pool override */
 577    POOL *inc_pool;                    /* Pool override */
 578    POOL *diff_pool;                   /* Pool override */
 579    STORE *storage;                    /* Storage override */
 580    MSGS *msgs;                        /* Messages override */
 581    char *since;
 582    int level_no;
 583    int minute;                        /* minute to run job */
 584    time_t last_run;                   /* last time run */
 585    time_t next_run;                   /* next time to run */
 586    char hour[nbytes_for_bits(24)];    /* bit set for each hour */
 587    char mday[nbytes_for_bits(31)];    /* bit set for each day of month */
 588    char month[nbytes_for_bits(12)];   /* bit set for each month */
 589    char wday[nbytes_for_bits(7)];     /* bit set for each day of the week */
 590    char wom[nbytes_for_bits(5)];      /* week of month */
 591    char woy[nbytes_for_bits(54)];     /* week of year */
 592 };