git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/protos.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 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 external function prototypes
  30  *
  31  *   Version $Id$
  32  */
  33
  34 /* admin.c */
  35 extern bool do_admin_init(JCR *jcr);
  36 extern bool do_admin(JCR *jcr);
  37 extern void admin_cleanup(JCR *jcr, int TermCode);
  38
  39
  40 /* authenticate.c */
  41 extern bool authenticate_storage_daemon(JCR *jcr, STORE *store);
  42 extern int authenticate_file_daemon(JCR *jcr);
  43 extern int authenticate_user_agent(UAContext *ua);
  44
  45 /* autoprune.c */
  46 extern void do_autoprune(JCR *jcr);
  47 extern bool prune_volumes(JCR *jcr, bool InChanger, MEDIA_DBR *mr);
  48
  49 /* autorecycle.c */
  50 extern bool recycle_oldest_purged_volume(JCR *jcr, bool InChanger, MEDIA_DBR *mr);
  51 extern int recycle_volume(JCR *jcr, MEDIA_DBR *mr);
  52 extern bool find_recycled_volume(JCR *jcr, bool InChanger, MEDIA_DBR *mr);
  53
  54 /* backup.c */
  55 extern int wait_for_job_termination(JCR *jcr, int timeout=0);
  56 extern bool do_backup_init(JCR *jcr);
  57 extern bool do_backup(JCR *jcr);
  58 extern void backup_cleanup(JCR *jcr, int TermCode);
  59 extern void update_bootstrap_file(JCR *jcr);
  60
  61 /* vbackup.c */
  62 extern bool do_vbackup_init(JCR *jcr);
  63 extern bool do_vbackup(JCR *jcr);
  64 extern void vbackup_cleanup(JCR *jcr, int TermCode);
  65
  66
  67 /* bsr.c */
  68 RBSR *new_bsr();
  69 void free_bsr(RBSR *bsr);
  70 bool complete_bsr(UAContext *ua, RBSR *bsr);
  71 uint32_t write_bsr_file(UAContext *ua, RESTORE_CTX &rx);
  72 void display_bsr_info(UAContext *ua, RESTORE_CTX &rx);
  73 void add_findex(RBSR *bsr, uint32_t JobId, int32_t findex);
  74 void add_findex_all(RBSR *bsr, uint32_t JobId);
  75 RBSR_FINDEX *new_findex();
  76 void make_unique_restore_filename(UAContext *ua, POOLMEM **fname);
  77 void print_bsr(UAContext *ua, RESTORE_CTX &rx);
  78
  79
  80 /* catreq.c */
  81 extern void catalog_request(JCR *jcr, BSOCK *bs);
  82 extern void catalog_update(JCR *jcr, BSOCK *bs);
  83
  84 /* dird_conf.c */
  85 extern const char *level_to_str(int level);
  86 extern "C" char *job_code_callback_filesetname(JCR *jcr, const char*);
  87
  88 /* expand.c */
  89 int variable_expansion(JCR *jcr, char *inp, POOLMEM **exp);
  90
  91
  92 /* fd_cmds.c */
  93 extern int connect_to_file_daemon(JCR *jcr, int retry_interval,
  94                                   int max_retry_time, int verbose);
  95 extern bool send_include_list(JCR *jcr);
  96 extern bool send_exclude_list(JCR *jcr);
  97 extern bool send_bootstrap_file(JCR *jcr, BSOCK *sock);
  98 extern bool send_level_command(JCR *jcr);
  99 extern int get_attributes_and_put_in_catalog(JCR *jcr);
 100 extern int get_attributes_and_compare_to_catalog(JCR *jcr, JobId_t JobId);
 101 extern int put_file_into_catalog(JCR *jcr, long file_index, char *fname,
 102                           char *link, char *attr, int stream);
 103 extern void get_level_since_time(JCR *jcr, char *since, int since_len);
 104 extern int send_runscripts_commands(JCR *jcr);
 105
 106 /* getmsg.c */
 107 enum e_prtmsg {
 108    DISPLAY_ERROR,
 109    NO_DISPLAY
 110 };
 111 extern bool response(JCR *jcr, BSOCK *fd, char *resp, const char *cmd, e_prtmsg prtmsg);
 112
 113 /* job.c */
 114 extern bool allow_duplicate_job(JCR *jcr);
 115 extern void set_jcr_defaults(JCR *jcr, JOB *job);
 116 extern void create_unique_job_name(JCR *jcr, const char *base_name);
 117 extern void update_job_end_record(JCR *jcr);
 118 extern bool get_or_create_client_record(JCR *jcr);
 119 extern bool get_or_create_fileset_record(JCR *jcr);
 120 extern DBId_t get_or_create_pool_record(JCR *jcr, char *pool_name);
 121 extern void apply_pool_overrides(JCR *jcr);
 122 extern JobId_t run_job(JCR *jcr);
 123 extern bool cancel_job(UAContext *ua, JCR *jcr);
 124 extern void get_job_storage(USTORE *store, JOB *job, RUN *run);
 125 extern void init_jcr_job_record(JCR *jcr);
 126 extern void update_job_end(JCR *jcr, int TermCode);
 127 extern void copy_rwstorage(JCR *jcr, alist *storage, const char *where);
 128 extern void set_rwstorage(JCR *jcr, USTORE *store);
 129 extern void free_rwstorage(JCR *jcr);
 130 extern void copy_wstorage(JCR *jcr, alist *storage, const char *where);
 131 extern void set_wstorage(JCR *jcr, USTORE *store);
 132 extern void free_wstorage(JCR *jcr);
 133 extern void copy_rstorage(JCR *jcr, alist *storage, const char *where);
 134 extern void set_rstorage(JCR *jcr, USTORE *store);
 135 extern void free_rstorage(JCR *jcr);
 136 extern bool setup_job(JCR *jcr);
 137 extern void create_clones(JCR *jcr);
 138 extern bool create_restore_bootstrap_file(JCR *jcr);
 139 extern void dird_free_jcr(JCR *jcr);
 140 extern void dird_free_jcr_pointers(JCR *jcr);
 141 extern void cancel_storage_daemon_job(JCR *jcr);
 142 extern bool run_console_command(JCR *jcr, const char *cmd);
 143
 144 /* migration.c */
 145 extern bool do_migration(JCR *jcr);
 146 extern bool do_migration_init(JCR *jcr);
 147 extern void migration_cleanup(JCR *jcr, int TermCode);
 148 extern bool set_migration_wstorage(JCR *jcr, POOL *pool);
 149
 150
 151 /* mountreq.c */
 152 extern void mount_request(JCR *jcr, BSOCK *bs, char *buf);
 153
 154 /* msgchan.c */
 155 extern bool connect_to_storage_daemon(JCR *jcr, int retry_interval,
 156                               int max_retry_time, int verbose);
 157 extern bool start_storage_daemon_job(JCR *jcr, alist *rstore, alist *wstore);
 158 extern bool start_storage_daemon_message_thread(JCR *jcr);
 159 extern int bget_dirmsg(BSOCK *bs);
 160 extern void wait_for_storage_daemon_termination(JCR *jcr);
 161
 162 /* next_vol.c */
 163 int find_next_volume_for_append(JCR *jcr, MEDIA_DBR *mr, int index,
 164                                 bool create, bool purge);
 165 bool has_volume_expired(JCR *jcr, MEDIA_DBR *mr);
 166 void check_if_volume_valid_or_recyclable(JCR *jcr, MEDIA_DBR *mr, const char **reason);
 167 bool get_scratch_volume(JCR *jcr, bool InChanger, MEDIA_DBR *mr);
 168
 169 /* newvol.c */
 170 bool newVolume(JCR *jcr, MEDIA_DBR *mr);
 171
 172 /* python.c */
 173 int generate_job_event(JCR *jcr, const char *event);
 174
 175
 176 /* restore.c */
 177 extern bool do_restore(JCR *jcr);
 178 extern bool do_restore_init(JCR *jcr);
 179 extern void restore_cleanup(JCR *jcr, int TermCode);
 180
 181
 182 /* ua_acl.c */
 183 bool acl_access_ok(UAContext *ua, int acl, const char *item);
 184 bool acl_access_ok(UAContext *ua, int acl, const char *item, int len);
 185
 186 /* ua_cmds.c */
 187 bool do_a_command(UAContext *ua);
 188 bool do_a_dot_command(UAContext *ua);
 189 int qmessagescmd(UAContext *ua, const char *cmd);
 190 bool open_client_db(UAContext *ua);
 191 bool open_db(UAContext *ua);
 192 void close_db(UAContext *ua);
 193 enum e_pool_op {
 194    POOL_OP_UPDATE,
 195    POOL_OP_CREATE
 196 };
 197 int create_pool(JCR *jcr, B_DB *db, POOL *pool, e_pool_op op);
 198 void set_pool_dbr_defaults_in_media_dbr(MEDIA_DBR *mr, POOL_DBR *pr);
 199 bool set_pooldbr_recyclepoolid(JCR *jcr, B_DB *db, POOL_DBR *pr, POOL *pool);
 200 void set_pooldbr_from_poolres(POOL_DBR *pr, POOL *pool, e_pool_op op);
 201 int update_pool_recyclepool(JCR *jcr, B_DB *db, POOL *pool);
 202
 203 /* ua_input.c */
 204 int get_cmd(UAContext *ua, const char *prompt);
 205 bool get_pint(UAContext *ua, const char *prompt);
 206 bool get_yesno(UAContext *ua, const char *prompt);
 207 bool is_yesno(char *val, int *ret);
 208 int get_enabled(UAContext *ua, const char *val);
 209 void parse_ua_args(UAContext *ua);
 210
 211 /* ua_label.c */
 212 bool is_volume_name_legal(UAContext *ua, const char *name);
 213 int get_num_drives_from_SD(UAContext *ua);
 214 void update_slots(UAContext *ua);
 215
 216 /* ua_update.c */
 217 void update_vol_pool(UAContext *ua, char *val, MEDIA_DBR *mr, POOL_DBR *opr);
 218
 219 /* ua_output.c */
 220 void prtit(void *ctx, const char *msg);
 221 bool complete_jcr_for_job(JCR *jcr, JOB *job, POOL *pool);
 222 RUN *find_next_run(RUN *run, JOB *job, time_t &runtime, int ndays);
 223
 224 /* ua_restore.c */
 225 int get_next_jobid_from_list(char **p, JobId_t *JobId);
 226 void find_storage_resource(UAContext *ua, RESTORE_CTX &rx, char *Storage, char *MediaType);
 227
 228 /* ua_server.c */
 229 void bsendmsg(void *ua_ctx, const char *fmt, ...);
 230 void berrormsg(void *ua_ctx, const char *fmt, ...);
 231 void bwarningmsg(void *ua_ctx, const char *fmt, ...);
 232 void binfomsg(void *ua_ctx, const char *fmt, ...);
 233 UAContext *new_ua_context(JCR *jcr);
 234 JCR *new_control_jcr(const char *base_name, int job_type);
 235 void free_ua_context(UAContext *ua);
 236
 237 /* ua_select.c */
 238 STORE   *select_storage_resource(UAContext *ua);
 239 JOB     *select_job_resource(UAContext *ua);
 240 JOB     *select_restore_job_resource(UAContext *ua);
 241 CLIENT  *select_client_resource(UAContext *ua);
 242 FILESET *select_fileset_resource(UAContext *ua);
 243 int     select_pool_and_media_dbr(UAContext *ua, POOL_DBR *pr, MEDIA_DBR *mr);
 244 int     select_media_dbr(UAContext *ua, MEDIA_DBR *mr);
 245 bool    select_pool_dbr(UAContext *ua, POOL_DBR *pr, const char *argk="pool");
 246 bool    select_client_dbr(UAContext *ua, CLIENT_DBR *cr);
 247
 248 void    start_prompt(UAContext *ua, const char *msg);
 249 void    add_prompt(UAContext *ua, const char *prompt);
 250 int     do_prompt(UAContext *ua, const char *automsg, const char *msg, char *prompt, int max_prompt);
 251 CAT    *get_catalog_resource(UAContext *ua);
 252 STORE  *get_storage_resource(UAContext *ua, bool use_default);
 253 int     get_storage_drive(UAContext *ua, STORE *store);
 254 int     get_storage_slot(UAContext *ua, STORE *store);
 255 int     get_media_type(UAContext *ua, char *MediaType, int max_media);
 256 bool    get_pool_dbr(UAContext *ua, POOL_DBR *pr, const char *argk="pool");
 257 bool    get_client_dbr(UAContext *ua, CLIENT_DBR *cr);
 258 POOL   *get_pool_resource(UAContext *ua);
 259 POOL   *select_pool_resource(UAContext *ua);
 260 CLIENT *get_client_resource(UAContext *ua);
 261 int     get_job_dbr(UAContext *ua, JOB_DBR *jr);
 262
 263 int find_arg_keyword(UAContext *ua, const char **list);
 264 int find_arg(UAContext *ua, const char *keyword);
 265 int find_arg_with_value(UAContext *ua, const char *keyword);
 266 int do_keyword_prompt(UAContext *ua, const char *msg, const char **list);
 267 int confirm_retention(UAContext *ua, utime_t *ret, const char *msg);
 268 bool get_level_from_name(JCR *jcr, const char *level_name);
 269
 270 /* ua_status.c */
 271 void list_dir_status_header(UAContext *ua);
 272
 273 /* ua_tree.c */
 274 bool user_select_files_from_tree(TREE_CTX *tree);
 275 int insert_tree_handler(void *ctx, int num_fields, char **row);
 276
 277 /* ua_prune.c */
 278 int prune_files(UAContext *ua, CLIENT *client);
 279 int prune_jobs(UAContext *ua, CLIENT *client, int JobType);
 280 int prune_stats(UAContext *ua, utime_t retention);
 281 bool prune_volume(UAContext *ua, MEDIA_DBR *mr);
 282 int job_delete_handler(void *ctx, int num_fields, char **row);
 283 int del_count_handler(void *ctx, int num_fields, char **row);
 284 int file_delete_handler(void *ctx, int num_fields, char **row);
 285 int get_prune_list_for_volume(UAContext *ua, MEDIA_DBR *mr, del_ctx *del);
 286
 287 /* ua_purge.c */
 288 bool is_volume_purged(UAContext *ua, MEDIA_DBR *mr);
 289 bool mark_media_purged(UAContext *ua, MEDIA_DBR *mr);
 290 void purge_files_from_volume(UAContext *ua, MEDIA_DBR *mr );
 291 bool purge_jobs_from_volume(UAContext *ua, MEDIA_DBR *mr);
 292 void purge_files_from_jobs(UAContext *ua, char *jobs);
 293 void purge_jobs_from_catalog(UAContext *ua, char *jobs);
 294 void purge_job_list_from_catalog(UAContext *ua, del_ctx &del);
 295 void purge_files_from_job_list(UAContext *ua, del_ctx &del);
 296
 297
 298 /* ua_run.c */
 299 extern int run_cmd(UAContext *ua, const char *cmd);
 300
 301 /* verify.c */
 302 extern bool do_verify(JCR *jcr);
 303 extern bool do_verify_init(JCR *jcr);
 304 extern void verify_cleanup(JCR *jcr, int TermCode);