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