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