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

   1 /*
   2    Bacula(R) - The Network Backup Solution
   3
   4    Copyright (C) 2000-2015 Kern Sibbald
   5    Copyright (C) 2000-2014 Free Software Foundation Europe e.V.
   6
   7    The original author of Bacula is Kern Sibbald, with contributions
   8    from many others, a complete list can be found in the file AUTHORS.
   9
  10    You may use this file and others of this release according to the
  11    license defined in the LICENSE file, which includes the Affero General
  12    Public License, v3.0 ("AGPLv3") and some additional permissions and
  13    terms pursuant to its AGPLv3 Section 7.
  14
  15    This notice must be preserved when any source code is
  16    conveyed and/or propagated.
  17
  18    Bacula(R) is a registered trademark of Kern Sibbald.
  19 */
  20 /*
  21  * Director external function prototypes
  22  */
  23
  24 /* admin.c */
  25 extern bool do_admin_init(JCR *jcr);
  26 extern bool do_admin(JCR *jcr);
  27 extern void admin_cleanup(JCR *jcr, int TermCode);
  28
  29
  30 /* authenticate.c */
  31 extern bool authenticate_storage_daemon(JCR *jcr, STORE *store);
  32 extern int authenticate_file_daemon(JCR *jcr);
  33 extern int authenticate_user_agent(UAContext *ua);
  34
  35 /* autoprune.c */
  36 extern void do_autoprune(JCR *jcr);
  37 extern void prune_volumes(JCR *jcr, bool InChanger, MEDIA_DBR *mr,
  38               STORE *store);
  39
  40 /* autorecycle.c */
  41 extern bool recycle_oldest_purged_volume(JCR *jcr, bool InChanger,
  42               MEDIA_DBR *mr, STORE *store);
  43
  44 extern int recycle_volume(JCR *jcr, MEDIA_DBR *mr);
  45 extern bool find_recycled_volume(JCR *jcr, bool InChanger,
  46                 MEDIA_DBR *mr, STORE *store);
  47
  48 /* backup.c */
  49 extern int wait_for_job_termination(JCR *jcr, int timeout=0);
  50 extern bool do_backup_init(JCR *jcr);
  51 extern bool do_backup(JCR *jcr);
  52 extern void backup_cleanup(JCR *jcr, int TermCode);
  53 extern void update_bootstrap_file(JCR *jcr);
  54 extern bool send_accurate_current_files(JCR *jcr);
  55 extern char *get_storage_address(CLIENT *cli, STORE *store);
  56 extern bool run_storage_and_start_message_thread(JCR *jcr, BSOCK *sd);
  57 extern bool send_client_addr_to_sd(JCR *jcr);
  58 extern bool send_store_addr_to_fd(JCR *jcr, STORE *store,
  59                char *store_address, uint32_t store_port);
  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 extern bool despool_attributes_from_file(JCR *jcr, const char *file);
  84
  85 /* dird_conf.c */
  86 extern const char *level_to_str(int level);
  87 extern "C" char *job_code_callback_director(JCR *jcr, const char*);
  88
  89 /* expand.c */
  90 int variable_expansion(JCR *jcr, char *inp, POOLMEM **exp);
  91
  92
  93 /* fd_cmds.c */
  94 extern int connect_to_file_daemon(JCR *jcr, int retry_interval,
  95                                   int max_retry_time, int verbose);
  96 extern bool send_ls_fileset(JCR *jcr, const char *path);
  97 extern bool send_include_list(JCR *jcr);
  98 extern bool send_exclude_list(JCR *jcr);
  99 extern bool send_level_command(JCR *jcr);
 100 extern bool send_bwlimit(JCR *jcr, const char *Job);
 101 extern int get_attributes_and_put_in_catalog(JCR *jcr);
 102 extern void get_attributes_and_compare_to_catalog(JCR *jcr, JobId_t JobId);
 103 extern int put_file_into_catalog(JCR *jcr, long file_index, char *fname,
 104                           char *link, char *attr, int stream);
 105 extern void get_level_since_time(JCR *jcr, char *since, int since_len);
 106 extern int send_runscripts_commands(JCR *jcr);
 107 extern bool send_restore_objects(JCR *jcr);
 108 extern bool send_component_info(JCR *jcr);
 109
 110 /* getmsg.c */
 111 enum e_prtmsg {
 112    DISPLAY_ERROR,
 113    NO_DISPLAY
 114 };
 115 extern bool response(JCR *jcr, BSOCK *fd, char *resp, const char *cmd, e_prtmsg prtmsg);
 116
 117 /* job.c */
 118 extern bool allow_duplicate_job(JCR *jcr);
 119 extern void set_jcr_defaults(JCR *jcr, JOB *job);
 120 extern void create_unique_job_name(JCR *jcr, const char *base_name);
 121 extern void update_job_end_record(JCR *jcr);
 122 extern bool get_or_create_client_record(JCR *jcr);
 123 extern bool get_or_create_fileset_record(JCR *jcr);
 124 extern DBId_t get_or_create_pool_record(JCR *jcr, char *pool_name);
 125 extern void apply_pool_overrides(JCR *jcr);
 126 extern bool apply_wstorage_overrides(JCR *jcr, POOL *original_pool);
 127 extern JobId_t run_job(JCR *jcr);
 128 extern JobId_t resume_job(JCR *jcr, JOB_DBR *jr);
 129 extern bool cancel_job(UAContext *ua, JCR *jcr, bool cancel=true);
 130 extern void get_job_storage(USTORE *store, JOB *job, RUN *run);
 131 extern void init_jcr_job_record(JCR *jcr);
 132 extern void update_job_end(JCR *jcr, int TermCode);
 133 extern void copy_rwstorage(JCR *jcr, alist *storage, const char *where);
 134 extern void set_rwstorage(JCR *jcr, USTORE *store);
 135 extern void free_rwstorage(JCR *jcr);
 136 extern void copy_wstorage(JCR *jcr, alist *storage, const char *where);
 137 extern void set_wstorage(JCR *jcr, USTORE *store);
 138 extern void free_wstorage(JCR *jcr);
 139 extern void copy_rstorage(JCR *jcr, alist *storage, const char *where);
 140 extern void set_rstorage(JCR *jcr, USTORE *store);
 141 extern void free_rstorage(JCR *jcr);
 142 extern bool setup_job(JCR *jcr);
 143 extern void create_clones(JCR *jcr);
 144 extern int create_restore_bootstrap_file(JCR *jcr);
 145 extern void dird_free_jcr(JCR *jcr);
 146 extern void dird_free_jcr_pointers(JCR *jcr);
 147 extern void cancel_storage_daemon_job(JCR *jcr);
 148 extern bool run_console_command(JCR *jcr, const char *cmd);
 149 extern void sd_msg_thread_send_signal(JCR *jcr, int sig);
 150
 151 /* jobq.c */
 152 extern bool inc_read_store(JCR *jcr);
 153 extern void dec_read_store(JCR *jcr);
 154
 155 /* mac.c */
 156 extern bool do_mac(JCR *jcr);
 157 extern bool do_mac_init(JCR *jcr);
 158 extern void mac_cleanup(JCR *jcr, int TermCode, int writeTermCode);
 159 extern bool set_mac_wstorage(UAContext *ua, JCR *jcr, POOL *pool,
 160                POOL *next_pool, const char *source);
 161
 162
 163 /* mountreq.c */
 164 extern void mount_request(JCR *jcr, BSOCK *bs, char *buf);
 165
 166 /* msgchan.c */
 167 extern BSOCK *open_sd_bsock(UAContext *ua);
 168 extern void close_sd_bsock(UAContext *ua);
 169 extern bool connect_to_storage_daemon(JCR *jcr, int retry_interval,
 170                               int max_retry_time, int verbose);
 171 extern bool start_storage_daemon_job(JCR *jcr, alist *rstore, alist *wstore,
 172               bool send_bsr=false);
 173 extern bool start_storage_daemon_message_thread(JCR *jcr);
 174 extern int bget_dirmsg(BSOCK *bs);
 175 extern void wait_for_storage_daemon_termination(JCR *jcr);
 176 extern bool send_bootstrap_file(JCR *jcr, BSOCK *sd);
 177
 178 /* next_vol.c */
 179 void set_storageid_in_mr(STORE *store, MEDIA_DBR *mr);
 180 int find_next_volume_for_append(JCR *jcr, MEDIA_DBR *mr, int index,
 181                                 bool create, bool purge);
 182 bool has_volume_expired(JCR *jcr, MEDIA_DBR *mr);
 183 void check_if_volume_valid_or_recyclable(JCR *jcr, MEDIA_DBR *mr, const char **reason);
 184 bool get_scratch_volume(JCR *jcr, bool InChanger, MEDIA_DBR *mr,
 185         STORE *store);
 186
 187 /* newvol.c */
 188 bool newVolume(JCR *jcr, MEDIA_DBR *mr, STORE *store);
 189
 190 /* restore.c */
 191 extern bool do_restore(JCR *jcr);
 192 extern bool do_restore_init(JCR *jcr);
 193 extern void restore_cleanup(JCR *jcr, int TermCode);
 194
 195
 196 /* ua_acl.c */
 197 bool acl_access_ok(UAContext *ua, int acl, const char *item);
 198 bool acl_access_ok(UAContext *ua, int acl, const char *item, int len);
 199 bool have_restricted_acl(UAContext *ua, int acl);
 200
 201 /* ua_cmds.c */
 202 bool do_a_command(UAContext *ua);
 203 bool do_a_dot_command(UAContext *ua);
 204 int qmessagescmd(UAContext *ua, const char *cmd);
 205 bool open_new_client_db(UAContext *ua);
 206 bool open_client_db(UAContext *ua);
 207 bool open_db(UAContext *ua);
 208 void close_db(UAContext *ua);
 209 enum e_pool_op {
 210    POOL_OP_UPDATE,
 211    POOL_OP_CREATE
 212 };
 213 int create_pool(JCR *jcr, BDB *db, POOL *pool, e_pool_op op);
 214 void set_pool_dbr_defaults_in_media_dbr(MEDIA_DBR *mr, POOL_DBR *pr);
 215 bool set_pooldbr_references(JCR *jcr, BDB *db, POOL_DBR *pr, POOL *pool);
 216 void set_pooldbr_from_poolres(POOL_DBR *pr, POOL *pool, e_pool_op op);
 217 int update_pool_references(JCR *jcr, BDB *db, POOL *pool);
 218
 219 /* ua_input.c */
 220 bool get_cmd(UAContext *ua, const char *prompt, bool subprompt=false);
 221 bool get_selection_list(UAContext *ua, sellist &sl, const char *prompt, bool subprompt=false);
 222 bool get_pint(UAContext *ua, const char *prompt);
 223 bool get_yesno(UAContext *ua, const char *prompt);
 224 bool is_yesno(char *val, int *ret);
 225 int get_enabled(UAContext *ua, const char *val);
 226 void parse_ua_args(UAContext *ua);
 227 bool is_comment_legal(UAContext *ua, const char *name);
 228
 229 /* ua_label.c */
 230 bool is_volume_name_legal(UAContext *ua, const char *name);
 231 int get_num_drives_from_SD(UAContext *ua);
 232 void update_slots(UAContext *ua);
 233
 234 /* ua_update.c */
 235 void update_vol_pool(UAContext *ua, char *val, MEDIA_DBR *mr, POOL_DBR *opr);
 236
 237 /* ua_output.c */
 238 void prtit(void *ctx, const char *msg);
 239 bool complete_jcr_for_job(JCR *jcr, JOB *job, POOL *pool);
 240 RUN *find_next_run(RUN *run, JOB *job, utime_t &runtime, int ndays);
 241 bool acl_access_jobid_ok(UAContext *ua, const char *jobids);
 242
 243 /* ua_restore.c */
 244 void find_storage_resource(UAContext *ua, RESTORE_CTX &rx, char *Storage, char *MediaType);
 245 bool insert_table_into_findex_list(UAContext *ua, RESTORE_CTX *rx, char *table);
 246 void new_rx(RESTORE_CTX *rx);
 247 void free_rx(RESTORE_CTX *rx);
 248
 249 /* ua_server.c */
 250 void bsendmsg(void *ua_ctx, const char *fmt, ...);
 251 void berrormsg(void *ua_ctx, const char *fmt, ...);
 252 void bwarningmsg(void *ua_ctx, const char *fmt, ...);
 253 void binfomsg(void *ua_ctx, const char *fmt, ...);
 254 UAContext *new_ua_context(JCR *jcr);
 255 JCR *new_control_jcr(const char *base_name, int job_type);
 256 void free_ua_context(UAContext *ua);
 257
 258 /* ua_select.c */
 259 STORE   *select_storage_resource(UAContext *ua, bool unique=false);
 260 JOB     *select_job_resource(UAContext *ua);
 261 JOB     *select_enable_disable_job_resource(UAContext *ua, bool enable);
 262 JOB     *select_restore_job_resource(UAContext *ua);
 263 CLIENT  *select_enable_disable_client_resource(UAContext *ua, bool enable);
 264 CLIENT  *select_client_resource(UAContext *ua);
 265 FILESET *select_fileset_resource(UAContext *ua);
 266 SCHED   *select_enable_disable_schedule_resource(UAContext *ua, bool enable);
 267 int     select_pool_and_media_dbr(UAContext *ua, POOL_DBR *pr, MEDIA_DBR *mr);
 268 int     select_media_dbr(UAContext *ua, MEDIA_DBR *mr);
 269 bool    select_pool_dbr(UAContext *ua, POOL_DBR *pr, const char *argk="pool");
 270 bool    select_client_dbr(UAContext *ua, CLIENT_DBR *cr);
 271
 272 void    start_prompt(UAContext *ua, const char *msg);
 273 void    add_prompt(UAContext *ua, const char *prompt, char *unique=NULL);
 274 int     do_prompt(UAContext *ua, const char *automsg, const char *msg, char *prompt, int max_prompt);
 275 int     do_alist_prompt(UAContext *ua, const char *automsg, const char *msg,
 276               alist *selected);
 277 CAT    *get_catalog_resource(UAContext *ua);
 278 STORE  *get_storage_resource(UAContext *ua, bool use_default, bool unique=false);
 279 int     get_storage_drive(UAContext *ua, STORE *store);
 280 int     get_storage_slot(UAContext *ua, STORE *store);
 281 int     get_media_type(UAContext *ua, char *MediaType, int max_media);
 282 bool    get_pool_dbr(UAContext *ua, POOL_DBR *pr, const char *argk="pool");
 283 bool    get_client_dbr(UAContext *ua, CLIENT_DBR *cr);
 284 POOL   *get_pool_resource(UAContext *ua);
 285 JOB    *get_restore_job(UAContext *ua);
 286 POOL   *select_pool_resource(UAContext *ua);
 287 int  select_running_jobs(UAContext *ua, alist *jcrs, const char *reason);
 288 CLIENT *get_client_resource(UAContext *ua);
 289 int     get_job_dbr(UAContext *ua, JOB_DBR *jr);
 290
 291 int find_arg_keyword(UAContext *ua, const char **list);
 292 int find_arg(UAContext *ua, const char *keyword);
 293 int find_arg_with_value(UAContext *ua, const char *keyword);
 294 int do_keyword_prompt(UAContext *ua, const char *msg, const char **list);
 295 int confirm_retention(UAContext *ua, utime_t *ret, const char *msg);
 296 int confirm_retention_yesno(UAContext *ua, utime_t ret, const char *msg);
 297 bool get_level_from_name(JCR *jcr, const char *level_name);
 298
 299 /* ua_status.c */
 300 void list_dir_status_header(UAContext *ua);
 301
 302 /* ua_tree.c */
 303 bool user_select_files_from_tree(TREE_CTX *tree);
 304 int insert_tree_handler(void *ctx, int num_fields, char **row);
 305
 306 /* ua_prune.c */
 307 int prune_files(UAContext *ua, CLIENT *client, POOL *pool);
 308 int prune_jobs(UAContext *ua, CLIENT *client, POOL *pool, int JobType);
 309 int prune_stats(UAContext *ua, utime_t retention);
 310 bool prune_volume(UAContext *ua, MEDIA_DBR *mr);
 311 int job_delete_handler(void *ctx, int num_fields, char **row);
 312 int del_count_handler(void *ctx, int num_fields, char **row);
 313 int file_delete_handler(void *ctx, int num_fields, char **row);
 314 int get_prune_list_for_volume(UAContext *ua, MEDIA_DBR *mr, del_ctx *del);
 315 int exclude_running_jobs_from_list(del_ctx *prune_list);
 316
 317 /* ua_purge.c */
 318 bool is_volume_purged(UAContext *ua, MEDIA_DBR *mr, bool force=false);
 319 bool mark_media_purged(UAContext *ua, MEDIA_DBR *mr);
 320 void purge_files_from_volume(UAContext *ua, MEDIA_DBR *mr);
 321 bool purge_jobs_from_volume(UAContext *ua, MEDIA_DBR *mr, bool force=false);
 322 void purge_files_from_jobs(UAContext *ua, char *jobs);
 323 void purge_jobs_from_catalog(UAContext *ua, char *jobs);
 324 void purge_job_list_from_catalog(UAContext *ua, del_ctx &del);
 325 void purge_files_from_job_list(UAContext *ua, del_ctx &del);
 326
 327
 328 /* ua_run.c */
 329 extern int run_cmd(UAContext *ua, const char *cmd);
 330 extern int restart_cmd(UAContext *ua, const char *cmd);
 331
 332 /* verify.c */
 333 extern bool do_verify(JCR *jcr);
 334 extern bool do_verify_init(JCR *jcr);
 335 extern void verify_cleanup(JCR *jcr, int TermCode);
 336
 337 /* snapshot.c */
 338 int  select_snapshot_dbr(UAContext *ua, SNAPSHOT_DBR *sr);
 339 void snapshot_list(UAContext *ua, int i, DB_LIST_HANDLER *sendit, e_list_type llist);
 340 int  snapshot_cmd(UAContext *ua, const char *cmd);
 341 int  snapshot_catreq(JCR *jcr, BSOCK *bs);
 342 int  delete_snapshot(UAContext *ua);
 343 bool update_snapshot(UAContext *ua);
 344 int prune_snapshot(UAContext *ua);
 345 bool send_snapshot_retention(JCR *jcr, utime_t val);