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