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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2014 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from many
   7    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    Bacula® is a registered trademark of Kern Sibbald.
  15 */
  16 /*
  17  * Director external function prototypes
  18  */
  19
  20 /* admin.c */
  21 extern bool do_admin_init(JCR *jcr);
  22 extern bool do_admin(JCR *jcr);
  23 extern void admin_cleanup(JCR *jcr, int TermCode);
  24
  25
  26 /* authenticate.c */
  27 extern bool authenticate_storage_daemon(JCR *jcr, STORE *store);
  28 extern int authenticate_file_daemon(JCR *jcr);
  29 extern int authenticate_user_agent(UAContext *ua);
  30
  31 /* autoprune.c */
  32 extern void do_autoprune(JCR *jcr);
  33 extern void prune_volumes(JCR *jcr, bool InChanger, MEDIA_DBR *mr,
  34               STORE *store);
  35
  36 /* autorecycle.c */
  37 extern bool recycle_oldest_purged_volume(JCR *jcr, bool InChanger,
  38               MEDIA_DBR *mr, STORE *store);
  39
  40 extern int recycle_volume(JCR *jcr, MEDIA_DBR *mr);
  41 extern bool find_recycled_volume(JCR *jcr, bool InChanger,
  42                 MEDIA_DBR *mr, STORE *store);
  43
  44 /* backup.c */
  45 extern int wait_for_job_termination(JCR *jcr, int timeout=0);
  46 extern bool do_backup_init(JCR *jcr);
  47 extern bool do_backup(JCR *jcr);
  48 extern void backup_cleanup(JCR *jcr, int TermCode);
  49 extern void update_bootstrap_file(JCR *jcr);
  50 extern bool send_accurate_current_files(JCR *jcr);
  51 extern char *get_storage_address(CLIENT *cli, STORE *store);
  52 extern bool run_storage_and_start_message_thread(JCR *jcr, BSOCK *sd);
  53 extern bool send_client_addr_to_sd(JCR *jcr);
  54 extern bool send_store_addr_to_fd(JCR *jcr, STORE *store,
  55                char *store_address, uint32_t store_port);
  56
  57 /* vbackup.c */
  58 extern bool do_vbackup_init(JCR *jcr);
  59 extern bool do_vbackup(JCR *jcr);
  60 extern void vbackup_cleanup(JCR *jcr, int TermCode);
  61
  62
  63 /* bsr.c */
  64 RBSR *new_bsr();
  65 void free_bsr(RBSR *bsr);
  66 bool complete_bsr(UAContext *ua, RBSR *bsr);
  67 uint32_t write_bsr_file(UAContext *ua, RESTORE_CTX &rx);
  68 void display_bsr_info(UAContext *ua, RESTORE_CTX &rx);
  69 void add_findex(RBSR *bsr, uint32_t JobId, int32_t findex);
  70 void add_findex_all(RBSR *bsr, uint32_t JobId);
  71 RBSR_FINDEX *new_findex();
  72 void make_unique_restore_filename(UAContext *ua, POOLMEM **fname);
  73 void print_bsr(UAContext *ua, RESTORE_CTX &rx);
  74
  75
  76 /* catreq.c */
  77 extern void catalog_request(JCR *jcr, BSOCK *bs);
  78 extern void catalog_update(JCR *jcr, BSOCK *bs);
  79 extern bool despool_attributes_from_file(JCR *jcr, const char *file);
  80
  81 /* dird_conf.c */
  82 extern const char *level_to_str(int level);
  83 extern "C" char *job_code_callback_director(JCR *jcr, const char*);
  84
  85 /* expand.c */
  86 int variable_expansion(JCR *jcr, char *inp, POOLMEM **exp);
  87
  88
  89 /* fd_cmds.c */
  90 extern int connect_to_file_daemon(JCR *jcr, int retry_interval,
  91                                   int max_retry_time, int verbose);
  92 extern bool send_ls_fileset(JCR *jcr, const char *path);
  93 extern bool send_include_list(JCR *jcr);
  94 extern bool send_exclude_list(JCR *jcr);
  95 extern bool send_level_command(JCR *jcr);
  96 extern bool send_bwlimit(JCR *jcr, const char *Job);
  97 extern int get_attributes_and_put_in_catalog(JCR *jcr);
  98 extern void get_attributes_and_compare_to_catalog(JCR *jcr, JobId_t JobId);
  99 extern int put_file_into_catalog(JCR *jcr, long file_index, char *fname,
 100                           char *link, char *attr, int stream);
 101 extern void get_level_since_time(JCR *jcr, char *since, int since_len);
 102 extern int send_runscripts_commands(JCR *jcr);
 103 extern bool send_restore_objects(JCR *jcr);
 104 extern bool send_component_info(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 bool apply_wstorage_overrides(JCR *jcr, POOL *original_pool);
 123 extern JobId_t run_job(JCR *jcr);
 124 extern bool cancel_job(UAContext *ua, JCR *jcr, bool cancel = true);
 125 extern void get_job_storage(USTORE *store, JOB *job, RUN *run);
 126 extern void init_jcr_job_record(JCR *jcr);
 127 extern void update_job_end(JCR *jcr, int TermCode);
 128 extern void copy_rwstorage(JCR *jcr, alist *storage, const char *where);
 129 extern void set_rwstorage(JCR *jcr, USTORE *store);
 130 extern void free_rwstorage(JCR *jcr);
 131 extern void copy_wstorage(JCR *jcr, alist *storage, const char *where);
 132 extern void set_wstorage(JCR *jcr, USTORE *store);
 133 extern void free_wstorage(JCR *jcr);
 134 extern void copy_rstorage(JCR *jcr, alist *storage, const char *where);
 135 extern void set_rstorage(JCR *jcr, USTORE *store);
 136 extern void free_rstorage(JCR *jcr);
 137 extern bool setup_job(JCR *jcr);
 138 extern void create_clones(JCR *jcr);
 139 extern int create_restore_bootstrap_file(JCR *jcr);
 140 extern void dird_free_jcr(JCR *jcr);
 141 extern void dird_free_jcr_pointers(JCR *jcr);
 142 extern void cancel_storage_daemon_job(JCR *jcr);
 143 extern bool run_console_command(JCR *jcr, const char *cmd);
 144 extern void sd_msg_thread_send_signal(JCR *jcr, int sig);
 145
 146 /* jobq.c */
 147 extern bool inc_read_store(JCR *jcr);
 148 extern void dec_read_store(JCR *jcr);
 149
 150 /* mac.c */
 151 extern bool do_mac(JCR *jcr);
 152 extern bool do_mac_init(JCR *jcr);
 153 extern void mac_cleanup(JCR *jcr, int TermCode, int writeTermCode);
 154 extern bool set_mac_wstorage(UAContext *ua, JCR *jcr, POOL *pool,
 155                POOL *next_pool, const char *source);
 156
 157
 158 /* mountreq.c */
 159 extern void mount_request(JCR *jcr, BSOCK *bs, char *buf);
 160
 161 /* msgchan.c */
 162 extern BSOCK *open_sd_bsock(UAContext *ua);
 163 extern void close_sd_bsock(UAContext *ua);
 164 extern bool connect_to_storage_daemon(JCR *jcr, int retry_interval,
 165                               int max_retry_time, int verbose);
 166 extern bool start_storage_daemon_job(JCR *jcr, alist *rstore, alist *wstore,
 167               bool send_bsr=false);
 168 extern bool start_storage_daemon_message_thread(JCR *jcr);
 169 extern int bget_dirmsg(BSOCK *bs);
 170 extern void wait_for_storage_daemon_termination(JCR *jcr);
 171 extern bool send_bootstrap_file(JCR *jcr, BSOCK *sd);
 172
 173 /* next_vol.c */
 174 void set_storageid_in_mr(STORE *store, MEDIA_DBR *mr);
 175 int find_next_volume_for_append(JCR *jcr, MEDIA_DBR *mr, int index,
 176                                 bool create, bool purge);
 177 bool has_volume_expired(JCR *jcr, MEDIA_DBR *mr);
 178 void check_if_volume_valid_or_recyclable(JCR *jcr, MEDIA_DBR *mr, const char **reason);
 179 bool get_scratch_volume(JCR *jcr, bool InChanger, MEDIA_DBR *mr,
 180         STORE *store);
 181
 182 /* newvol.c */
 183 bool newVolume(JCR *jcr, MEDIA_DBR *mr, STORE *store);
 184
 185 /* restore.c */
 186 extern bool do_restore(JCR *jcr);
 187 extern bool do_restore_init(JCR *jcr);
 188 extern void restore_cleanup(JCR *jcr, int TermCode);
 189
 190
 191 /* ua_acl.c */
 192 bool acl_access_ok(UAContext *ua, int acl, const char *item);
 193 bool acl_access_ok(UAContext *ua, int acl, const char *item, int len);
 194 bool have_restricted_acl(UAContext *ua, int acl);
 195
 196 /* ua_cmds.c */
 197 bool do_a_command(UAContext *ua);
 198 bool do_a_dot_command(UAContext *ua);
 199 int qmessagescmd(UAContext *ua, const char *cmd);
 200 bool open_new_client_db(UAContext *ua);
 201 bool open_client_db(UAContext *ua);
 202 bool open_db(UAContext *ua);
 203 void close_db(UAContext *ua);
 204 enum e_pool_op {
 205    POOL_OP_UPDATE,
 206    POOL_OP_CREATE
 207 };
 208 int create_pool(JCR *jcr, B_DB *db, POOL *pool, e_pool_op op);
 209 void set_pool_dbr_defaults_in_media_dbr(MEDIA_DBR *mr, POOL_DBR *pr);
 210 bool set_pooldbr_references(JCR *jcr, B_DB *db, POOL_DBR *pr, POOL *pool);
 211 void set_pooldbr_from_poolres(POOL_DBR *pr, POOL *pool, e_pool_op op);
 212 int update_pool_references(JCR *jcr, B_DB *db, POOL *pool);
 213
 214 /* ua_input.c */
 215 bool get_cmd(UAContext *ua, const char *prompt, bool subprompt=false);
 216 bool get_selection_list(UAContext *ua, sellist &sl, const char *prompt, bool subprompt=false);
 217 bool get_pint(UAContext *ua, const char *prompt);
 218 bool get_yesno(UAContext *ua, const char *prompt);
 219 bool is_yesno(char *val, int *ret);
 220 int get_enabled(UAContext *ua, const char *val);
 221 void parse_ua_args(UAContext *ua);
 222 bool is_comment_legal(UAContext *ua, const char *name);
 223
 224 /* ua_label.c */
 225 bool is_volume_name_legal(UAContext *ua, const char *name);
 226 int get_num_drives_from_SD(UAContext *ua);
 227 void update_slots(UAContext *ua);
 228
 229 /* ua_update.c */
 230 void update_vol_pool(UAContext *ua, char *val, MEDIA_DBR *mr, POOL_DBR *opr);
 231
 232 /* ua_output.c */
 233 void prtit(void *ctx, const char *msg);
 234 bool complete_jcr_for_job(JCR *jcr, JOB *job, POOL *pool);
 235 RUN *find_next_run(RUN *run, JOB *job, utime_t &runtime, int ndays);
 236 bool acl_access_jobid_ok(UAContext *ua, const char *jobids);
 237
 238 /* ua_restore.c */
 239 void find_storage_resource(UAContext *ua, RESTORE_CTX &rx, char *Storage, char *MediaType);
 240
 241 /* ua_server.c */
 242 void bsendmsg(void *ua_ctx, const char *fmt, ...);
 243 void berrormsg(void *ua_ctx, const char *fmt, ...);
 244 void bwarningmsg(void *ua_ctx, const char *fmt, ...);
 245 void binfomsg(void *ua_ctx, const char *fmt, ...);
 246 UAContext *new_ua_context(JCR *jcr);
 247 JCR *new_control_jcr(const char *base_name, int job_type);
 248 void free_ua_context(UAContext *ua);
 249
 250 /* ua_select.c */
 251 STORE   *select_storage_resource(UAContext *ua, bool unique=false);
 252 JOB     *select_job_resource(UAContext *ua);
 253 JOB     *select_enable_disable_job_resource(UAContext *ua, bool enable);
 254 JOB     *select_restore_job_resource(UAContext *ua);
 255 CLIENT  *select_client_resource(UAContext *ua);
 256 FILESET *select_fileset_resource(UAContext *ua);
 257 int     select_pool_and_media_dbr(UAContext *ua, POOL_DBR *pr, MEDIA_DBR *mr);
 258 int     select_media_dbr(UAContext *ua, MEDIA_DBR *mr);
 259 bool    select_pool_dbr(UAContext *ua, POOL_DBR *pr, const char *argk="pool");
 260 bool    select_client_dbr(UAContext *ua, CLIENT_DBR *cr);
 261
 262 void    start_prompt(UAContext *ua, const char *msg);
 263 void    add_prompt(UAContext *ua, const char *prompt, char *unique=NULL);
 264 int     do_prompt(UAContext *ua, const char *automsg, const char *msg, char *prompt, int max_prompt);
 265 int     do_alist_prompt(UAContext *ua, const char *automsg, const char *msg,
 266               alist *selected);
 267 CAT    *get_catalog_resource(UAContext *ua);
 268 STORE  *get_storage_resource(UAContext *ua, bool use_default, bool unique=false);
 269 int     get_storage_drive(UAContext *ua, STORE *store);
 270 int     get_storage_slot(UAContext *ua, STORE *store);
 271 int     get_media_type(UAContext *ua, char *MediaType, int max_media);
 272 bool    get_pool_dbr(UAContext *ua, POOL_DBR *pr, const char *argk="pool");
 273 bool    get_client_dbr(UAContext *ua, CLIENT_DBR *cr);
 274 POOL   *get_pool_resource(UAContext *ua);
 275 JOB    *get_restore_job(UAContext *ua);
 276 POOL   *select_pool_resource(UAContext *ua);
 277 int  select_running_jobs(UAContext *ua, alist *jcrs, const char *reason);
 278 CLIENT *get_client_resource(UAContext *ua);
 279 int     get_job_dbr(UAContext *ua, JOB_DBR *jr);
 280
 281 int find_arg_keyword(UAContext *ua, const char **list);
 282 int find_arg(UAContext *ua, const char *keyword);
 283 int find_arg_with_value(UAContext *ua, const char *keyword);
 284 int do_keyword_prompt(UAContext *ua, const char *msg, const char **list);
 285 int confirm_retention(UAContext *ua, utime_t *ret, const char *msg);
 286 bool get_level_from_name(JCR *jcr, const char *level_name);
 287
 288 /* ua_status.c */
 289 void list_dir_status_header(UAContext *ua);
 290
 291 /* ua_tree.c */
 292 bool user_select_files_from_tree(TREE_CTX *tree);
 293 int insert_tree_handler(void *ctx, int num_fields, char **row);
 294
 295 /* ua_prune.c */
 296 int prune_files(UAContext *ua, CLIENT *client, POOL *pool);
 297 int prune_jobs(UAContext *ua, CLIENT *client, POOL *pool, int JobType);
 298 int prune_stats(UAContext *ua, utime_t retention);
 299 bool prune_volume(UAContext *ua, MEDIA_DBR *mr);
 300 int job_delete_handler(void *ctx, int num_fields, char **row);
 301 int del_count_handler(void *ctx, int num_fields, char **row);
 302 int file_delete_handler(void *ctx, int num_fields, char **row);
 303 int get_prune_list_for_volume(UAContext *ua, MEDIA_DBR *mr, del_ctx *del);
 304 int exclude_running_jobs_from_list(del_ctx *prune_list);
 305
 306 /* ua_purge.c */
 307 bool is_volume_purged(UAContext *ua, MEDIA_DBR *mr, bool force=false);
 308 bool mark_media_purged(UAContext *ua, MEDIA_DBR *mr);
 309 void purge_files_from_volume(UAContext *ua, MEDIA_DBR *mr);
 310 bool purge_jobs_from_volume(UAContext *ua, MEDIA_DBR *mr, bool force=false);
 311 void purge_files_from_jobs(UAContext *ua, char *jobs);
 312 void purge_jobs_from_catalog(UAContext *ua, char *jobs);
 313 void purge_job_list_from_catalog(UAContext *ua, del_ctx &del);
 314 void purge_files_from_job_list(UAContext *ua, del_ctx &del);
 315
 316
 317 /* ua_run.c */
 318 extern int run_cmd(UAContext *ua, const char *cmd);
 319
 320 /* verify.c */
 321 extern bool do_verify(JCR *jcr);
 322 extern bool do_verify_init(JCR *jcr);
 323 extern void verify_cleanup(JCR *jcr, int TermCode);