git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/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  * Prototypes for lib directory of Bacula
  21  *
  22  */
  23
  24 #ifndef __LIBPROTOS_H
  25 #define __LIBPROTOS_H
  26
  27 class JCR;
  28
  29 /* address_conf.c */
  30 void remove_duplicate_addresses(dlist *addr_list);
  31
  32 /* attr.c */
  33 ATTR     *new_attr(JCR *jcr);
  34 void      free_attr(ATTR *attr);
  35 int       unpack_attributes_record(JCR *jcr, int32_t stream, char *rec, int32_t reclen, ATTR *attr);
  36 void      build_attr_output_fnames(JCR *jcr, ATTR *attr);
  37 void      print_ls_output(JCR *jcr, ATTR *attr, int message_type=M_RESTORED);
  38
  39 /* base64.c */
  40 void      base64_init            (void);
  41 int       to_base64              (int64_t value, char *where);
  42 int       from_base64            (int64_t *value, char *where);
  43 int       bin_to_base64          (char *buf, int buflen, char *bin, int binlen,
  44                                   int compatible);
  45 int       base64_to_bin(char *dest, int destlen, char *src, int srclen);
  46
  47 /* bjson.c */
  48 void strip_long_opts(char *out, const char *in);
  49 void edit_alist(HPKT &hpkt);
  50 void edit_msg_types(HPKT &hpkt, DEST *dest);
  51 void display_msgs(HPKT &hpkt);
  52 void display_alist(HPKT &hpkt);
  53 bool display_alist_str(HPKT &hpkt);
  54 bool display_alist_res(HPKT &hpkt);
  55 void display_res(HPKT &hpkt);
  56 void display_string_pair(HPKT &hpkt);
  57 void display_int32_pair(HPKT &hpkt);
  58 void display_int64_pair(HPKT &hpkt);
  59 void display_bool_pair(HPKT &hpkt);
  60 void display_bit_pair(HPKT &hpkt);
  61 bool byte_is_set(char *byte, int num);
  62 void display_bit_array(char *array, int num);
  63 void display_last(HPKT &hpkt);
  64 void init_hpkt(HPKT &hpkt);
  65 void term_hpkt(HPKT &hpkt);
  66 bool display_global_item(HPKT &hpkt);
  67
  68 /* bsys.c */
  69 typedef enum {
  70    WAIT_READ  = 1,
  71    WAIT_WRITE = 2
  72 } fd_wait_mode;
  73 int fd_wait_data(int fd, fd_wait_mode mode, int sec, int msec);
  74 FILE *bfopen(const char *path, const char *mode);
  75 int baccept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
  76 int copyfile(const char *src, const char *dst);
  77 void setup_env(char *envp[]);
  78 POOLMEM  *quote_string           (POOLMEM *snew, const char *old);
  79 POOLMEM  *quote_where            (POOLMEM *snew, const char *old);
  80 char     *bstrncpy               (char *dest, const char *src, int maxlen);
  81 char     *bstrncpy               (char *dest, POOL_MEM &src, int maxlen);
  82 char     *bstrncat               (char *dest, const char *src, int maxlen);
  83 char     *bstrncat               (char *dest, POOL_MEM &src, int maxlen);
  84 bool      bstrcmp                (const char *s1, const char *s2);
  85 bool      bstrcasecmp            (const char *s1, const char *s2);
  86 int       cstrlen                (const char *str);
  87 void     *b_malloc               (const char *file, int line, size_t size);
  88 #ifndef bmalloc
  89 void     *bmalloc                (size_t size);
  90 #endif
  91 void      bfree                  (void *buf);
  92 void     *brealloc               (void *buf, size_t size);
  93 void     *bcalloc                (size_t size1, size_t size2);
  94 int       bsnprintf              (char *str, int32_t size, const char *format, ...);
  95 int       bvsnprintf             (char *str, int32_t size, const char *format, va_list ap);
  96 int       pool_sprintf           (char *pool_buf, const char *fmt, ...);
  97 int       create_lock_file       (char *fname, const char *progname, const char *filetype, POOLMEM **errmsg, int *fd);
  98 void      create_pid_file        (char *dir, const char *progname, int port);
  99 int       delete_pid_file        (char *dir, const char *progname, int port);
 100 void      drop                   (char *uid, char *gid, bool keep_readall_caps);
 101 int reset_job_user();
 102 int change_job_user(char *uname, char *gname, char *errmsg, int errlen);
 103
 104 int       bmicrosleep            (int32_t sec, int32_t usec);
 105 char     *bfgets                 (char *s, int size, FILE *fd);
 106 char     *bfgets                 (POOLMEM *&s, FILE *fd);
 107 void      make_unique_filename   (POOLMEM **name, int Id, char *what);
 108 #ifndef HAVE_STRTOLL
 109 long long int strtoll            (const char *ptr, char **endptr, int base);
 110 #endif
 111 void      read_state_file(char *dir, const char *progname, int port);
 112 int       b_strerror(int errnum, char *buf, size_t bufsiz);
 113 char     *escape_filename(const char *file_path);
 114 int       Zdeflate(char *in, int in_len, char *out, int &out_len);
 115 int       Zinflate(char *in, int in_len, char *out, int &out_len);
 116 void      stack_trace();
 117 int       safer_unlink(const char *pathname, const char *regex);
 118 int fs_get_free_space(const char *path, int64_t *freeval, int64_t *totalval);
 119
 120 /* bnet.c */
 121 bool       bnet_tls_server       (TLS_CONTEXT *ctx, BSOCK *bsock,
 122                                   alist *verify_list);
 123 bool       bnet_tls_client       (TLS_CONTEXT *ctx, BSOCK *bsock,
 124                                   alist *verify_list);
 125 BSOCK *    init_bsock            (JCR *jcr, int sockfd, const char *who, const char *ip,
 126                                   int port, struct sockaddr *client_addr);
 127 #ifdef HAVE_WIN32
 128 #ifndef socklen_t
 129 #define socklen_t int
 130 #endif
 131 #endif
 132 int        bnet_get_peer           (BSOCK *bs, char *buf, socklen_t buflen);
 133 BSOCK *    dup_bsock             (BSOCK *bsock);
 134 void       term_bsock            (BSOCK *bsock);
 135 const char *bnet_strerror         (BSOCK *bsock);
 136 const char *bnet_sig_to_ascii     (int32_t msglen);
 137 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr);
 138 void       bnet_restore_blocking (BSOCK *sock, int flags);
 139 int        set_socket_errno(int sockstat);
 140
 141 /* bget_msg.c */
 142 int      bget_msg(BSOCK *sock);
 143
 144 /* bpipe.c */
 145 BPIPE *          open_bpipe(char *prog, int wait, const char *mode, char *envp[]=NULL);
 146 int              close_wpipe(BPIPE *bpipe);
 147 int              close_bpipe(BPIPE *bpipe);
 148
 149 /* cram-md5.c */
 150 bool cram_md5_respond(BSOCK *bs, const char *password, int *tls_remote_need, int *compatible);
 151 bool cram_md5_challenge(BSOCK *bs, const char *password, int tls_local_need, int compatible);
 152 void hmac_md5(uint8_t* text, int text_len, uint8_t* key, int key_len, uint8_t *hmac);
 153
 154 /* crc32.c */
 155
 156 uint32_t bcrc32(unsigned char *buf, int len);
 157
 158
 159 /* crypto.c */
 160 int                init_crypto                 (void);
 161 int                cleanup_crypto              (void);
 162 DIGEST *           crypto_digest_new           (JCR *jcr, crypto_digest_t type);
 163 bool               crypto_digest_update        (DIGEST *digest, const uint8_t *data, uint32_t length);
 164 bool               crypto_digest_finalize      (DIGEST *digest, uint8_t *dest, uint32_t *length);
 165 void               crypto_digest_free          (DIGEST *digest);
 166 SIGNATURE *        crypto_sign_new             (JCR *jcr);
 167 crypto_error_t     crypto_sign_get_digest      (SIGNATURE *sig, X509_KEYPAIR *keypair,
 168                                                 crypto_digest_t &algorithm, DIGEST **digest);
 169 crypto_error_t     crypto_sign_verify          (SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest);
 170 int                crypto_sign_add_signer      (SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair);
 171 int                crypto_sign_encode          (SIGNATURE *sig, uint8_t *dest, uint32_t *length);
 172 SIGNATURE *        crypto_sign_decode          (JCR *jcr, const uint8_t *sigData, uint32_t length);
 173 void               crypto_sign_free            (SIGNATURE *sig);
 174 CRYPTO_SESSION *   crypto_session_new          (crypto_cipher_t cipher, alist *pubkeys);
 175 void               crypto_session_free         (CRYPTO_SESSION *cs);
 176 bool               crypto_session_encode       (CRYPTO_SESSION *cs, uint8_t *dest, uint32_t *length);
 177 crypto_error_t     crypto_session_decode       (const uint8_t *data, uint32_t length, alist *keypairs, CRYPTO_SESSION **session);
 178 CRYPTO_SESSION *   crypto_session_decode       (const uint8_t *data, uint32_t length);
 179 CIPHER_CONTEXT *   crypto_cipher_new           (CRYPTO_SESSION *cs, bool encrypt, uint32_t *blocksize);
 180 bool               crypto_cipher_update        (CIPHER_CONTEXT *cipher_ctx, const uint8_t *data, uint32_t length, const uint8_t *dest, uint32_t *written);
 181 bool               crypto_cipher_finalize      (CIPHER_CONTEXT *cipher_ctx, uint8_t *dest, uint32_t *written);
 182 void               crypto_cipher_free          (CIPHER_CONTEXT *cipher_ctx);
 183 X509_KEYPAIR *     crypto_keypair_new          (void);
 184 X509_KEYPAIR *     crypto_keypair_dup          (X509_KEYPAIR *keypair);
 185 int                crypto_keypair_load_cert    (X509_KEYPAIR *keypair, const char *file);
 186 bool               crypto_keypair_has_key      (const char *file);
 187 int                crypto_keypair_load_key     (X509_KEYPAIR *keypair, const char *file, CRYPTO_PEM_PASSWD_CB *pem_callback, const void *pem_userdata);
 188 void               crypto_keypair_free         (X509_KEYPAIR *keypair);
 189 int                crypto_default_pem_callback (char *buf, int size, const void *userdata);
 190 const char *       crypto_digest_name          (DIGEST *digest);
 191 crypto_digest_t    crypto_digest_stream_type   (int stream);
 192 const char *       crypto_strerror             (crypto_error_t error);
 193
 194 /* daemon.c */
 195 void     daemon_start            ();
 196
 197 /* edit.c */
 198 uint64_t         str_to_uint64(char *str);
 199 int64_t          str_to_int64(char *str);
 200 #define str_to_int32(str) ((int32_t)str_to_int64(str))
 201 char *           edit_uint64_with_commas   (uint64_t val, char *buf);
 202 char *           edit_uint64_with_suffix   (uint64_t val, char *buf);
 203 char *           add_commas              (char *val, char *buf);
 204 char *           edit_uint64             (uint64_t val, char *buf);
 205 char *           edit_int64              (int64_t val, char *buf);
 206 char *           edit_int64_with_commas  (int64_t val, char *buf);
 207 bool             duration_to_utime       (char *str, utime_t *value);
 208 bool             size_to_uint64(char *str, int str_len, uint64_t *rtn_value);
 209 bool             speed_to_uint64(char *str, int str_len, uint64_t *rtn_value);
 210 char             *edit_utime             (utime_t val, char *buf, int buf_len);
 211 bool             is_a_number             (const char *num);
 212 bool             is_a_number_list        (const char *n);
 213 bool             is_an_integer           (const char *n);
 214 bool             is_name_valid           (const char *name, POOLMEM **msg);
 215
 216 /* jcr.c (most definitions are in src/jcr.h) */
 217 void     init_last_jobs_list();
 218 void     term_last_jobs_list();
 219 void     lock_last_jobs_list();
 220 void     unlock_last_jobs_list();
 221 bool     read_last_jobs_list(int fd, uint64_t addr);
 222 uint64_t write_last_jobs_list(int fd, uint64_t addr);
 223 void     write_state_file(char *dir, const char *progname, int port);
 224 void     job_end_push(JCR *jcr, void job_end_cb(JCR *jcr,void *), void *ctx);
 225 void     lock_jobs();
 226 void     unlock_jobs();
 227 JCR     *jcr_walk_start();
 228 JCR     *jcr_walk_next(JCR *prev_jcr);
 229 void     jcr_walk_end(JCR *jcr);
 230 int      job_count();
 231 JCR     *get_jcr_from_tsd();
 232 void     set_jcr_in_tsd(JCR *jcr);
 233 void     remove_jcr_from_tsd(JCR *jcr);
 234 uint32_t get_jobid_from_tsd();
 235 uint32_t get_jobid_from_tid(pthread_t tid);
 236
 237
 238 /* lex.c */
 239 LEX *     lex_close_file         (LEX *lf);
 240 LEX *     lex_open_file          (LEX *lf, const char *fname, LEX_ERROR_HANDLER *scan_error);
 241 LEX *     lex_open_buf           (LEX *lf, const char *buf, LEX_ERROR_HANDLER *scan_error);
 242 int       lex_get_char           (LEX *lf);
 243 void      lex_unget_char         (LEX *lf);
 244 const char *  lex_tok_to_str     (int token);
 245 int       lex_get_token          (LEX *lf, int expect);
 246 void      lex_set_default_error_handler (LEX *lf);
 247 int       lex_set_error_handler_error_type (LEX *lf, int err_type);
 248 bool      lex_check_eol          (LEX *lf);
 249
 250 /* Required typedef, not in a C file */
 251 extern "C" {
 252    typedef char *(*job_code_callback_t)(JCR *, const char *, char *, int);
 253 }
 254
 255 /* message.c */
 256 void       my_name_is            (int argc, char *argv[], const char *name);
 257 void       init_msg              (JCR *jcr, MSGS *msg, job_code_callback_t job_code_callback = NULL);
 258 void       term_msg              (void);
 259 void       close_msg             (JCR *jcr);
 260 void       add_msg_dest          (MSGS *msg, int dest, int type, char *where, char *dest_code);
 261 void       rem_msg_dest          (MSGS *msg, int dest, int type, char *where);
 262 void       Jmsg                  (JCR *jcr, int type, utime_t mtime, const char *fmt, ...);
 263 void       dispatch_message      (JCR *jcr, int type, utime_t mtime, char *buf);
 264 void       init_console_msg      (const char *wd);
 265 void       free_msgs_res         (MSGS *msgs);
 266 void       dequeue_messages      (JCR *jcr);
 267 void       set_db_engine_name    (const char *name);
 268 void       set_trace             (int trace_flag);
 269 bool       get_trace             (void);
 270 void       set_hangup            (int hangup_value);
 271 void       set_blowup            (int blowup_value);
 272 int        get_hangup            (void);
 273 int        get_blowup            (void);
 274 bool       handle_hangup_blowup  (JCR *jcr, uint32_t file_count, uint64_t byte_count);
 275 void       set_assert_msg        (const char *file, int line, const char *msg);
 276 void       register_message_callback(void msg_callback(int type, char *msg));
 277 void       setup_daemon_message_queue();
 278 void       free_daemon_message_queue();
 279
 280 /* bnet_server.c */
 281 void       bnet_thread_server(dlist *addr_list, int max_clients,
 282               workq_t *client_wq, void *handle_client_request(void *bsock));
 283 void       bnet_stop_thread_server(pthread_t tid);
 284 void             bnet_server             (int port, void handle_client_request(BSOCK *bsock));
 285 int              net_connect             (int port);
 286 BSOCK *          bnet_bind               (int port);
 287 BSOCK *          bnet_accept             (BSOCK *bsock, char *who);
 288
 289 /* message.c */
 290 typedef int (EVENT_HANDLER)(JCR *jcr, const char *event);
 291 int generate_daemon_event(JCR *jcr, const char *event);
 292
 293 /* signal.c */
 294 void             init_signals             (void terminate(int sig));
 295 void             init_stack_dump          (void);
 296
 297 /* Used to display specific job information after a fatal signal */
 298 typedef void (dbg_hook_t)(FILE *fp);
 299 void dbg_add_hook(dbg_hook_t *fct);
 300
 301 /* scan.c */
 302 void             strip_leading_space     (char *str);
 303 char            *strip_trailing_junk     (char *str);
 304 char            *strip_trailing_newline  (char *str);
 305 char            *strip_trailing_slashes  (char *dir);
 306 bool             skip_spaces             (char **msg);
 307 bool             skip_nonspaces          (char **msg);
 308 int              fstrsch                 (const char *a, const char *b);
 309 char            *next_arg(char **s);
 310 int              parse_args(POOLMEM *cmd, POOLMEM **args, int *argc,
 311                         char **argk, char **argv, int max_args);
 312 int              parse_args_only(POOLMEM *cmd, POOLMEM **args, int *argc,
 313                         char **argk, char **argv, int max_args);
 314 void            split_path_and_filename(const char *fname, POOLMEM **path,
 315                         int *pnl, POOLMEM **file, int *fnl);
 316 int             bsscanf(const char *buf, const char *fmt, ...);
 317
 318
 319 /* tls.c */
 320 TLS_CONTEXT      *new_tls_context        (const char *ca_certfile,
 321                                           const char *ca_certdir,
 322                                           const char *certfile,
 323                                           const char *keyfile,
 324                                           CRYPTO_PEM_PASSWD_CB *pem_callback,
 325                                           const void *pem_userdata,
 326                                           const char *dhfile,
 327                                           bool verify_peer);
 328 void             free_tls_context        (TLS_CONTEXT *ctx);
 329 #ifdef HAVE_TLS
 330 bool             tls_postconnect_verify_host(JCR *jcr, TLS_CONNECTION *tls,
 331                                                const char *host);
 332 bool             tls_postconnect_verify_cn(JCR *jcr, TLS_CONNECTION *tls,
 333                                                alist *verify_list);
 334 TLS_CONNECTION   *new_tls_connection     (TLS_CONTEXT *ctx, int fd);
 335 bool             tls_bsock_accept        (BSOCK *bsock);
 336 int              tls_bsock_writen        (BSOCK *bsock, char *ptr, int32_t nbytes);
 337 int              tls_bsock_readn         (BSOCK *bsock, char *ptr, int32_t nbytes);
 338 bool             tls_bsock_probe         (BSOCK *bsock);
 339 #endif /* HAVE_TLS */
 340 bool             tls_bsock_connect       (BSOCK *bsock);
 341 void             tls_bsock_shutdown      (BSOCK *bsock);
 342 void             free_tls_connection     (TLS_CONNECTION *tls);
 343 bool             get_tls_require         (TLS_CONTEXT *ctx);
 344 bool             get_tls_enable          (TLS_CONTEXT *ctx);
 345
 346
 347 /* util.c */
 348 void             bmemzero                (void *buf, size_t size);
 349 bool             is_null                 (const void *ptr);
 350 bool             is_buf_zero             (const char *buf, int len);
 351 void             lcase                   (char *str);
 352 void             bash_spaces             (char *str);
 353 void             bash_spaces             (POOL_MEM &pm);
 354 void             unbash_spaces           (char *str);
 355 void             unbash_spaces           (POOL_MEM &pm);
 356 char *           encode_time             (utime_t time, char *buf);
 357 char *           encode_mode             (mode_t mode, char *buf);
 358 char *           hexdump(const char *data, int len, char *buf, int capacity, bool add_spaces=true);
 359 char *           asciidump(const char *data, int len, char *buf, int capacity);
 360 char *           smartdump(const char *data, int len, char *buf, int capacity, bool *is_ascii=NULL);
 361 int              is_power_of_two         (uint64_t x);
 362 int              do_shell_expansion      (char *name, int name_len);
 363 void             jobstatus_to_ascii      (int JobStatus, char *msg, int maxlen);
 364 void             jobstatus_to_ascii_gui  (int JobStatus, char *msg, int maxlen);
 365 int              run_program             (char *prog, int wait, POOLMEM *&results);
 366 int              run_program_full_output (char *prog, int wait, POOLMEM *&results, char *env[]=NULL);
 367 char *           action_on_purge_to_string(int aop, POOL_MEM &ret);
 368 const char *     job_type_to_str         (int type);
 369 const char *     job_status_to_str       (int stat, int errors);
 370 const char *     job_level_to_str        (int level);
 371 const char *     volume_status_to_str    (const char *status);
 372 void             make_session_key        (char *key, char *seed, int mode);
 373 void             encode_session_key      (char *encode, char *session, char *key, int maxlen);
 374 void             decode_session_key      (char *decode, char *session, char *key, int maxlen);
 375 POOLMEM *        edit_job_codes          (JCR *jcr, char *omsg, char *imsg, const char *to, job_code_callback_t job_code_callback = NULL);
 376 void             set_working_directory   (char *wd);
 377 const char *     last_path_separator     (const char *str);
 378
 379 /* watchdog.c */
 380 int start_watchdog(void);
 381 int stop_watchdog(void);
 382 watchdog_t *new_watchdog(void);
 383 bool register_watchdog(watchdog_t *wd);
 384 bool unregister_watchdog(watchdog_t *wd);
 385 bool is_watchdog();
 386
 387 /* timers.c */
 388 btimer_t *start_child_timer(JCR *jcr, pid_t pid, uint32_t wait);
 389 void stop_child_timer(btimer_t *wid);
 390 btimer_t *start_thread_timer(JCR *jcr, pthread_t tid, uint32_t wait);
 391 void stop_thread_timer(btimer_t *wid);
 392 btimer_t *start_bsock_timer(BSOCK *bs, uint32_t wait);
 393 void stop_bsock_timer(btimer_t *wid);
 394
 395 #endif /* __LIBPROTOS_H */