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

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2000-2012 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 three of the GNU Affero 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 Affero 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
  32 /* admin.c */
  33 extern bool do_admin_init(JCR *jcr);
  34 extern bool do_admin(JCR *jcr);
  35 extern void admin_cleanup(JCR *jcr, int TermCode);
  36
  37
  38 /* authenticate.c */
  39 extern bool authenticate_storage_daemon(JCR *jcr, STORE *store);
  40 extern int authenticate_file_daemon(JCR *jcr);
  41 extern int authenticate_user_agent(UAContext *ua);
  42
  43 /* autoprune.c */
  44 extern void do_autoprune(JCR *jcr);
  45 extern void prune_volumes(JCR *jcr, bool InChanger, MEDIA_DBR *mr,
  46               STORE *store);
  47
  48 /* autorecycle.c */
  49 extern bool recycle_oldest_purged_volume(JCR *jcr, bool InChanger,
  50               MEDIA_DBR *mr, STORE *store);
  51
  52 extern int recycle_volume(JCR *jcr, MEDIA_DBR *mr);
  53 extern bool find_recycled_volume(JCR *jcr, bool InChanger,
  54                 MEDIA_DBR *mr, STORE *store);
  55
  56 /* backup.c */
  57 extern int wait_for_job_termination(JCR *jcr, int timeout=0);
  58 extern bool do_backup_init(JCR *jcr);
  59 extern bool do_backup(JCR *jcr);
  60 extern void backup_cleanup(JCR *jcr, int TermCode);
  61 extern void update_bootstrap_file(JCR *jcr);
  62 extern bool send_accurate_current_files(JCR *jcr);
  63
  64
  65 /* vbackup.c */
  66 extern bool do_vbackup_init(JCR *jcr);
  67 extern bool do_vbackup(JCR *jcr);
  68 extern void vbackup_cleanup(JCR *jcr, int TermCode);
  69
  70
  71 /* bsr.c */
  72 RBSR *new_bsr();
  73 void free_bsr(RBSR *bsr);
  74 bool complete_bsr(UAContext *ua, RBSR *bsr);
  75 uint32_t write_bsr_file(UAContext *ua, RESTORE_CTX &rx);
  76 void display_bsr_info(UAContext *ua, RESTORE_CTX &rx);
  77 void add_findex(RBSR *bsr, uint32_t JobId, int32_t findex);
  78 void add_findex_all(RBSR *bsr, uint32_t JobId);
  79 RBSR_FINDEX *new_findex();
  80 void make_unique_restore_filename(UAContext *ua, POOLMEM **fname);
  81 void print_bsr(UAContext *ua, RESTORE_CTX &rx);
  82
  83
  84 /* catreq.c */
  85 extern void catalog_request(JCR *jcr, BSOCK *bs);
  86 extern void catalog_update(JCR *jcr, BSOCK *bs);
  87 extern bool despool_attributes_from_file(JCR *jcr, const char *file);
  88
  89 /* dird_conf.c */
  90 extern const char *level_to_str(int level);
  91 extern "C" char *job_code_callback_director(JCR *jcr, const char*);
  92
  93 /* expand.c */
  94 int variable_expansion(JCR *jcr, char *inp, POOLMEM **exp);
  95
  96
  97 /* fd_cmds.c */
  98 extern int connect_to_file_daemon(JCR *jcr, int retry_interval,
  99                                   int max_retry_time, int verbose);
 100 extern bool send_include_list(JCR *jcr);
 101 extern bool send_exclude_list(JCR *jcr);
 102 extern bool send_level_command(JCR *jcr);
 103 extern int get_attributes_and_put_in_catalog(JCR *jcr);
 104 extern void get_attributes_and_compare_to_catalog(JCR *jcr, JobId_t JobId);
 105 extern int put_file_into_catalog(JCR *jcr, long file_index, char *fname,
 106                           char *link, char *attr, int stream);
 107 extern void get_level_since_time(JCR *jcr, char *since, int since_len);
 108 extern int send_runscripts_commands(JCR *jcr);
 109 extern bool send_restore_objects(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 JobId_t run_job(JCR *jcr);
 128 extern bool cancel_job(UAContext *ua, JCR *jcr);
 129 extern void get_job_storage(USTORE *store, JOB *job, RUN *run);
 130 extern void init_jcr_job_record(JCR *jcr);
 131 extern void update_job_end(JCR *jcr, int TermCode);
 132 extern void copy_rwstorage(JCR *jcr, alist *storage, const char *where);
 133 extern void set_rwstorage(JCR *jcr, USTORE *store);
 134 extern void free_rwstorage(JCR *jcr);
 135 extern void copy_wstorage(JCR *jcr, alist *storage, const char *where);
 136 extern void set_wstorage(JCR *jcr, USTORE *store);
 137 extern void free_wstorage(JCR *jcr);
 138 extern void copy_rstorage(JCR *jcr, alist *storage, const char *where);
 139 extern void set_rstorage(JCR *jcr, USTORE *store);
 140 extern void free_rstorage(JCR *jcr);
 141 extern bool setup_job(JCR *jcr);
 142 extern void create_clones(JCR *jcr);
 143 extern int create_restore_bootstrap_file(JCR *jcr);
 144 extern void dird_free_jcr(JCR *jcr);
 145 extern void dird_free_jcr_pointers(JCR *jcr);
 146 extern void cancel_storage_daemon_job(JCR *jcr);
 147 extern bool run_console_command(JCR *jcr, const char *cmd);
 148 extern void sd_msg_thread_send_signal(JCR *jcr, int sig);
 149
 150 /* jobq.c */
 151 extern bool inc_read_store(JCR *jcr);
 152 extern void dec_read_store(JCR *jcr);
 153
 154 /* migration.c */
 155 extern bool do_migration(JCR *jcr);
 156 extern bool do_migration_init(JCR *jcr);
 157 extern void migration_cleanup(JCR *jcr, int TermCode);
 158 extern bool set_migration_wstorage(JCR *jcr, POOL *pool);
 159
 160
 161 /* mountreq.c */
 162 extern void mount_request(JCR *jcr, BSOCK *bs, char *buf);
 163
 164 /* msgchan.c */
 165 extern bool connect_to_storage_daemon(JCR *jcr, int retry_interval,
 166                               int max_retry_time, int verbose);
 167 extern bool start_storage_daemon_job(JCR *jcr, alist *rstore, alist *wstore,
 168               bool send_bsr=false);
 169 extern bool start_storage_daemon_message_thread(JCR *jcr);
 170 extern int bget_dirmsg(BSOCK *bs);
 171 extern void wait_for_storage_daemon_termination(JCR *jcr);
 172 extern bool send_bootstrap_file(JCR *jcr, BSOCK *sd);
 173
 174 /* next_vol.c */
 175 void set_storageid_in_mr(STORE *store, MEDIA_DBR *mr);
 176 int find_next_volume_for_append(JCR *jcr, MEDIA_DBR *mr, int index,
 177                                 bool create, bool purge);
 178 bool has_volume_expired(JCR *jcr, MEDIA_DBR *mr);
 179 void check_if_volume_valid_or_recyclable(JCR *jcr, MEDIA_DBR *mr, const char **reason);
 180 bool get_scratch_volume(JCR *jcr, bool InChanger, MEDIA_DBR *mr,
 181         STORE *store);
 182
 183 /* newvol.c */
 184 bool newVolume(JCR *jcr, MEDIA_DBR *mr, STORE *store);
 185
 186 /* python.c */
 187 int generate_job_event(JCR *jcr, const char *event);
 188
 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
 200 /* ua_cmds.c */
 201 bool do_a_command(UAContext *ua);
 202 bool do_a_dot_command(UAContext *ua);
 203 int qmessagescmd(UAContext *ua, const char *cmd);
 204 bool open_new_client_db(UAContext *ua);
 205 bool open_client_db(UAContext *ua);
 206 bool open_db(UAContext *ua);
 207 void close_db(UAContext *ua);
 208 enum e_pool_op {
 209    POOL_OP_UPDATE,
 210    POOL_OP_CREATE
 211 };
 212 int create_pool(JCR *jcr, B_DB *db, POOL *pool, e_pool_op op);
 213 void set_pool_dbr_defaults_in_media_dbr(MEDIA_DBR *mr, POOL_DBR *pr);
 214 bool set_pooldbr_references(JCR *jcr, B_DB *db, POOL_DBR *pr, POOL *pool);
 215 void set_pooldbr_from_poolres(POOL_DBR *pr, POOL *pool, e_pool_op op);
 216 int update_pool_references(JCR *jcr, B_DB *db, POOL *pool);
 217
 218 /* ua_input.c */
 219 int get_cmd(UAContext *ua, const char *prompt, bool subprompt=false);
 220 bool get_pint(UAContext *ua, const char *prompt);
 221 bool get_yesno(UAContext *ua, const char *prompt);
 222 bool is_yesno(char *val, int *ret);
 223 int get_enabled(UAContext *ua, const char *val);
 224 void parse_ua_args(UAContext *ua);
 225 bool is_comment_legal(UAContext *ua, const char *name);
 226
 227 /* ua_label.c */
 228 bool is_volume_name_legal(UAContext *ua, const char *name);
 229 int get_num_drives_from_SD(UAContext *ua);
 230 void update_slots(UAContext *ua);
 231
 232 /* ua_update.c */
 233 void update_vol_pool(UAContext *ua, char *val, MEDIA_DBR *mr, POOL_DBR *opr);
 234
 235 /* ua_output.c */
 236 void prtit(void *ctx, const char *msg);
 237 bool complete_jcr_for_job(JCR *jcr, JOB *job, POOL *pool);
 238 RUN *find_next_run(RUN *run, JOB *job, utime_t &runtime, int ndays);
 239
 240 /* ua_restore.c */
 241 void find_storage_resource(UAContext *ua, RESTORE_CTX &rx, char *Storage, char *MediaType);
 242
 243 /* ua_server.c */
 244 void bsendmsg(void *ua_ctx, const char *fmt, ...);
 245 void berrormsg(void *ua_ctx, const char *fmt, ...);
 246 void bwarningmsg(void *ua_ctx, const char *fmt, ...);
 247 void binfomsg(void *ua_ctx, const char *fmt, ...);
 248 UAContext *new_ua_context(JCR *jcr);
 249 JCR *new_control_jcr(const char *base_name, int job_type);
 250 void free_ua_context(UAContext *ua);
 251
 252 /* ua_select.c */
 253 STORE   *select_storage_resource(UAContext *ua);
 254 JOB     *select_job_resource(UAContext *ua);
 255 JOB     *select_enable_disable_job_resource(UAContext *ua, bool enable);
 256 JOB     *select_restore_job_resource(UAContext *ua);
 257 CLIENT  *select_client_resource(UAContext *ua);
 258 FILESET *select_fileset_resource(UAContext *ua);
 259 int     select_pool_and_media_dbr(UAContext *ua, POOL_DBR *pr, MEDIA_DBR *mr);
 260 int     select_media_dbr(UAContext *ua, MEDIA_DBR *mr);
 261 bool    select_pool_dbr(UAContext *ua, POOL_DBR *pr, const char *argk="pool");
 262 bool    select_client_dbr(UAContext *ua, CLIENT_DBR *cr);
 263
 264 void    start_prompt(UAContext *ua, const char *msg);
 265 void    add_prompt(UAContext *ua, const char *prompt);
 266 int     do_prompt(UAContext *ua, const char *automsg, const char *msg, char *prompt, int max_prompt);
 267 CAT    *get_catalog_resource(UAContext *ua);
 268 STORE  *get_storage_resource(UAContext *ua, bool use_default);
 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 JCR *select_running_job(UAContext *ua, 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);