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

   1 /*
   2  * Director specific configuration and defines
   3  *
   4  *     Kern Sibbald, Feb MM
   5  *
   6  *    Version $Id$
   7  */
   8 /*
   9    Bacula® - The Network Backup Solution
  10
  11    Copyright (C) 2000-2006 Free Software Foundation Europe e.V.
  12
  13    The main author of Bacula is Kern Sibbald, with contributions from
  14    many others, a complete list can be found in the file AUTHORS.
  15    This program is Free Software; you can redistribute it and/or
  16    modify it under the terms of version two of the GNU General Public
  17    License as published by the Free Software Foundation plus additions
  18    that are listed in the file LICENSE.
  19
  20    This program is distributed in the hope that it will be useful, but
  21    WITHOUT ANY WARRANTY; without even the implied warranty of
  22    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  23    General Public License for more details.
  24
  25    You should have received a copy of the GNU General Public License
  26    along with this program; if not, write to the Free Software
  27    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  28    02110-1301, USA.
  29
  30    Bacula® is a registered trademark ofJohn Walker.
  31    The licensor of Bacula is the Free Software Foundation Europe
  32    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  33    Switzerland, email:ftf@fsfeurope.org.
  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    TLS_CONTEXT *tls_ctx;              /* Shared TLS Context */
 258    bool tls_enable;                   /* Enable TLS */
 259    bool tls_require;                  /* Require TLS */
 260    bool AutoPrune;                    /* Do automatic pruning? */
 261
 262    /* Methods */
 263    char *name() const;
 264 };
 265
 266 inline char *CLIENT::name() const { return hdr.name; }
 267
 268
 269 /*
 270  *   Store Resource
 271  *
 272  */
 273 class STORE {
 274 public:
 275    RES   hdr;
 276
 277    int   SDport;                      /* port where Directors connect */
 278    int   SDDport;                     /* data port for File daemon */
 279    char *address;
 280    char *password;
 281    char *media_type;
 282    alist *device;                     /* Alternate devices for this Storage */
 283    uint32_t MaxConcurrentJobs;        /* Maximume concurrent jobs */
 284    uint32_t NumConcurrentJobs;        /* number of concurrent jobs running */
 285    char *tls_ca_certfile;             /* TLS CA Certificate File */
 286    char *tls_ca_certdir;              /* TLS CA Certificate Directory */
 287    char *tls_certfile;                /* TLS Client Certificate File */
 288    char *tls_keyfile;                 /* TLS Client Key File */
 289    TLS_CONTEXT *tls_ctx;              /* Shared TLS Context */
 290    bool tls_enable;                   /* Enable TLS */
 291    bool tls_require;                  /* Require TLS */
 292    bool enabled;                      /* Set if device is enabled */
 293    bool  autochanger;                 /* set if autochanger */
 294    int64_t StorageId;                 /* Set from Storage DB record */
 295    int  drives;                       /* number of drives in autochanger */
 296
 297    /* Methods */
 298    char *dev_name() const;
 299    char *name() const;
 300 };
 301
 302 inline char *STORE::dev_name() const
 303 {
 304    DEVICE *dev = (DEVICE *)device->first();
 305    return dev->hdr.name;
 306 }
 307
 308 inline char *STORE::name() const { return hdr.name; }
 309
 310
 311 /*
 312  *   Job Resource
 313  */
 314 class JOB {
 315 public:
 316    RES   hdr;
 317
 318    int   JobType;                     /* job type (backup, verify, restore */
 319    int   JobLevel;                    /* default backup/verify level */
 320    int   Priority;                    /* Job priority */
 321    int   RestoreJobId;                /* What -- JobId to restore */
 322    char *RestoreWhere;                /* Where on disk to restore -- directory */
 323    char *RestoreBootstrap;            /* Bootstrap file */
 324    alist *RunScripts;                 /* Run {client} program {after|before} Job */
 325    union {
 326       char *WriteBootstrap;           /* Where to write bootstrap Job updates */
 327       char *WriteVerifyList;          /* List of changed files */
 328    };
 329    int   replace;                     /* How (overwrite, ..) */
 330    utime_t MaxRunTime;                /* max run time in seconds */
 331    utime_t MaxWaitTime;               /* max blocking time in seconds */
 332    utime_t FullMaxWaitTime;           /* Max Full job wait time */
 333    utime_t DiffMaxWaitTime;           /* Max Differential job wait time */
 334    utime_t IncMaxWaitTime;            /* Max Incremental job wait time */
 335    utime_t MaxStartDelay;             /* max start delay in seconds */
 336    utime_t RescheduleInterval;        /* Reschedule interval */
 337    utime_t JobRetention;              /* job retention period in seconds */
 338    uint32_t MaxConcurrentJobs;        /* Maximum concurrent jobs */
 339    int RescheduleTimes;               /* Number of times to reschedule job */
 340    bool RescheduleOnError;            /* Set to reschedule on error */
 341    bool PrefixLinks;                  /* prefix soft links with Where path */
 342    bool PruneJobs;                    /* Force pruning of Jobs */
 343    bool PruneFiles;                   /* Force pruning of Files */
 344    bool PruneVolumes;                 /* Force pruning of Volumes */
 345    bool SpoolAttributes;              /* Set to spool attributes in SD */
 346    bool spool_data;                   /* Set to spool data in SD */
 347    bool rerun_failed_levels;          /* Upgrade to rerun failed levels */
 348    bool PreferMountedVolumes;         /* Prefer vols mounted rather than new one */
 349    bool write_part_after_job;         /* Set to write part after job in SD */
 350    bool enabled;                      /* Set if job enabled */
 351
 352    MSGS      *messages;               /* How and where to send messages */
 353    SCHED     *schedule;               /* When -- Automatic schedule */
 354    CLIENT    *client;                 /* Who to backup */
 355    FILESET   *fileset;                /* What to backup -- Fileset */
 356    alist     *storage;                /* Where is device -- list of Storage to be used */
 357    POOL      *pool;                   /* Where is media -- Media Pool */
 358    POOL      *full_pool;              /* Pool for Full backups */
 359    POOL      *inc_pool;               /* Pool for Incremental backups */
 360    POOL      *diff_pool;              /* Pool for Differental backups */
 361    char      *selection_pattern;
 362    int        selection_type;
 363    union {
 364       JOB       *verify_job;          /* Job name to verify */
 365    };
 366    JOB       *jobdefs;                /* Job defaults */
 367    alist     *run_cmds;               /* Run commands */
 368    uint32_t NumConcurrentJobs;        /* number of concurrent jobs running */
 369
 370    /* Methods */
 371    char *name() const;
 372 };
 373
 374 inline char *JOB::name() const { return hdr.name; }
 375
 376 #undef  MAX_FOPTS
 377 #define MAX_FOPTS 34
 378
 379 /* File options structure */
 380 struct FOPTS {
 381    char opts[MAX_FOPTS];              /* options string */
 382    alist regex;                       /* regex string(s) */
 383    alist regexdir;                    /* regex string(s) for directories */
 384    alist regexfile;                   /* regex string(s) for files */
 385    alist wild;                        /* wild card strings */
 386    alist wilddir;                     /* wild card strings for directories */
 387    alist wildfile;                    /* wild card strings for files */
 388    alist wildbase;                    /* wild card strings for files without '/' */
 389    alist base;                        /* list of base names */
 390    alist fstype;                      /* file system type limitation */
 391    alist drivetype;                   /* drive type limitation */
 392    char *reader;                      /* reader program */
 393    char *writer;                      /* writer program */
 394 };
 395
 396
 397 /* This is either an include item or an exclude item */
 398 struct INCEXE {
 399    FOPTS *current_opts;               /* points to current options structure */
 400    FOPTS **opts_list;                 /* options list */
 401    int num_opts;                      /* number of options items */
 402    alist name_list;                   /* filename list -- holds char * */
 403 };
 404
 405 /*
 406  *   FileSet Resource
 407  *
 408  */
 409 class FILESET {
 410 public:
 411    RES   hdr;
 412
 413    bool new_include;                  /* Set if new include used */
 414    INCEXE **include_items;            /* array of incexe structures */
 415    int num_includes;                  /* number in array */
 416    INCEXE **exclude_items;
 417    int num_excludes;
 418    bool have_MD5;                     /* set if MD5 initialized */
 419    struct MD5Context md5c;            /* MD5 of include/exclude */
 420    char MD5[30];                      /* base 64 representation of MD5 */
 421    bool ignore_fs_changes;            /* Don't force Full if FS changed */
 422    bool enable_vss;                   /* Enable Volume Shadow Copy */
 423
 424    /* Methods */
 425    char *name() const;
 426 };
 427
 428 inline char *FILESET::name() const { return hdr.name; }
 429
 430 /*
 431  *   Schedule Resource
 432  *
 433  */
 434 class SCHED {
 435 public:
 436    RES   hdr;
 437
 438    RUN *run;
 439 };
 440
 441 /*
 442  *   Counter Resource
 443  */
 444 class COUNTER {
 445 public:
 446    RES   hdr;
 447
 448    int32_t  MinValue;                 /* Minimum value */
 449    int32_t  MaxValue;                 /* Maximum value */
 450    int32_t  CurrentValue;             /* Current value */
 451    COUNTER *WrapCounter;              /* Wrap counter name */
 452    CAT     *Catalog;                  /* Where to store */
 453    bool     created;                  /* Created in DB */
 454    /* Methods */
 455    char *name() const;
 456 };
 457
 458 inline char *COUNTER::name() const { return hdr.name; }
 459
 460 /*
 461  *   Pool Resource
 462  *
 463  */
 464 class POOL {
 465 public:
 466    RES   hdr;
 467
 468    char *pool_type;                   /* Pool type */
 469    char *label_format;                /* Label format string */
 470    char *cleaning_prefix;             /* Cleaning label prefix */
 471    int32_t LabelType;                 /* Bacula/ANSI/IBM label type */
 472    uint32_t max_volumes;              /* max number of volumes */
 473    utime_t VolRetention;              /* volume retention period in seconds */
 474    utime_t VolUseDuration;            /* duration volume can be used */
 475    uint32_t MaxVolJobs;               /* Maximum jobs on the Volume */
 476    uint32_t MaxVolFiles;              /* Maximum files on the Volume */
 477    uint64_t MaxVolBytes;              /* Maximum bytes on the Volume */
 478    utime_t MigrationTime;             /* Time to migrate to next pool */
 479    uint64_t MigrationHighBytes;       /* When migration starts */
 480    uint64_t MigrationLowBytes;        /* When migration stops */
 481    POOL  *NextPool;                   /* Next pool for migration */
 482    alist *storage;                    /* Where is device -- list of Storage to be used */
 483    bool  use_catalog;                 /* maintain catalog for media */
 484    bool  catalog_files;               /* maintain file entries in catalog */
 485    bool  use_volume_once;             /* write on volume only once */
 486    bool  purge_oldest_volume;         /* purge oldest volume */
 487    bool  recycle_oldest_volume;       /* attempt to recycle oldest volume */
 488    bool  recycle_current_volume;      /* attempt recycle of current volume */
 489    bool  AutoPrune;                   /* default for pool auto prune */
 490    bool  Recycle;                     /* default for media recycle yes/no */
 491
 492    /* Methods */
 493    char *name() const;
 494 };
 495
 496 inline char *POOL::name() const { return hdr.name; }
 497
 498
 499
 500
 501 /* Define the Union of all the above
 502  * resource structure definitions.
 503  */
 504 union URES {
 505    DIRRES     res_dir;
 506    CONRES     res_con;
 507    CLIENT     res_client;
 508    STORE      res_store;
 509    CAT        res_cat;
 510    JOB        res_job;
 511    FILESET    res_fs;
 512    SCHED      res_sch;
 513    POOL       res_pool;
 514    MSGS       res_msgs;
 515    COUNTER    res_counter;
 516    DEVICE     res_dev;
 517    RES        hdr;
 518    RUNSCRIPT  res_runscript;
 519 };
 520
 521
 522
 523 /* Run structure contained in Schedule Resource */
 524 class RUN {
 525 public:
 526    RUN *next;                         /* points to next run record */
 527    int level;                         /* level override */
 528    int Priority;                      /* priority override */
 529    int job_type;
 530    bool spool_data;                   /* Data spooling override */
 531    bool spool_data_set;               /* Data spooling override given */
 532    bool write_part_after_job;         /* Write part after job override */
 533    bool write_part_after_job_set;     /* Write part after job override given */
 534
 535    POOL *pool;                        /* Pool override */
 536    POOL *full_pool;                   /* Pool override */
 537    POOL *inc_pool;                    /* Pool override */
 538    POOL *diff_pool;                   /* Pool override */
 539    STORE *storage;                    /* Storage override */
 540    MSGS *msgs;                        /* Messages override */
 541    char *since;
 542    int level_no;
 543    int minute;                        /* minute to run job */
 544    time_t last_run;                   /* last time run */
 545    time_t next_run;                   /* next time to run */
 546    char hour[nbytes_for_bits(24)];    /* bit set for each hour */
 547    char mday[nbytes_for_bits(31)];    /* bit set for each day of month */
 548    char month[nbytes_for_bits(12)];   /* bit set for each month */
 549    char wday[nbytes_for_bits(7)];     /* bit set for each day of the week */
 550    char wom[nbytes_for_bits(5)];      /* week of month */
 551    char woy[nbytes_for_bits(54)];     /* week of year */
 552 };