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