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 uint32_t bcrc32_bad(unsigned char *buf, int len);
 158
 159
 160 /* crypto.c */
 161 int                init_crypto                 (void);
 162 int                cleanup_crypto              (void);
 163 DIGEST *           crypto_digest_new           (JCR *jcr, crypto_digest_t type);
 164 bool               crypto_digest_update        (DIGEST *digest, const uint8_t *data, uint32_t length);
 165 bool               crypto_digest_finalize      (DIGEST *digest, uint8_t *dest, uint32_t *length);
 166 void               crypto_digest_free          (DIGEST *digest);
 167 SIGNATURE *        crypto_sign_new             (JCR *jcr);
 168 crypto_error_t     crypto_sign_get_digest      (SIGNATURE *sig, X509_KEYPAIR *keypair,
 169                                                 crypto_digest_t &algorithm, DIGEST **digest);
 170 crypto_error_t     crypto_sign_verify          (SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest);
 171 int                crypto_sign_add_signer      (SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair);
 172 int                crypto_sign_encode          (SIGNATURE *sig, uint8_t *dest, uint32_t *length);
 173 SIGNATURE *        crypto_sign_decode          (JCR *jcr, const uint8_t *sigData, uint32_t length);
 174 void               crypto_sign_free            (SIGNATURE *sig);
 175 CRYPTO_SESSION *   crypto_session_new          (crypto_cipher_t cipher, alist *pubkeys);
 176 void               crypto_session_free         (CRYPTO_SESSION *cs);
 177 bool               crypto_session_encode       (CRYPTO_SESSION *cs, uint8_t *dest, uint32_t *length);
 178 crypto_error_t     crypto_session_decode       (const uint8_t *data, uint32_t length, alist *keypairs, CRYPTO_SESSION **session);
 179 CRYPTO_SESSION *   crypto_session_decode       (const uint8_t *data, uint32_t length);
 180 CIPHER_CONTEXT *   crypto_cipher_new           (CRYPTO_SESSION *cs, bool encrypt, uint32_t *blocksize);
 181 bool               crypto_cipher_update        (CIPHER_CONTEXT *cipher_ctx, const uint8_t *data, uint32_t length, const uint8_t *dest, uint32_t *written);
 182 bool               crypto_cipher_finalize      (CIPHER_CONTEXT *cipher_ctx, uint8_t *dest, uint32_t *written);
 183 void               crypto_cipher_free          (CIPHER_CONTEXT *cipher_ctx);
 184 X509_KEYPAIR *     crypto_keypair_new          (void);
 185 X509_KEYPAIR *     crypto_keypair_dup          (X509_KEYPAIR *keypair);
 186 int                crypto_keypair_load_cert    (X509_KEYPAIR *keypair, const char *file);
 187 bool               crypto_keypair_has_key      (const char *file);
 188 int                crypto_keypair_load_key     (X509_KEYPAIR *keypair, const char *file, CRYPTO_PEM_PASSWD_CB *pem_callback, const void *pem_userdata);
 189 void               crypto_keypair_free         (X509_KEYPAIR *keypair);
 190 int                crypto_default_pem_callback (char *buf, int size, const void *userdata);
 191 const char *       crypto_digest_name          (DIGEST *digest);
 192 crypto_digest_t    crypto_digest_stream_type   (int stream);
 193 const char *       crypto_strerror             (crypto_error_t error);
 194
 195 /* daemon.c */
 196 void     daemon_start            ();
 197
 198 /* edit.c */
 199 uint64_t         str_to_uint64(char *str);
 200 int64_t          str_to_int64(char *str);
 201 #define str_to_int32(str) ((int32_t)str_to_int64(str))
 202 char *           edit_uint64_with_commas   (uint64_t val, char *buf);
 203 char *           edit_uint64_with_suffix   (uint64_t val, char *buf);
 204 char *           add_commas              (char *val, char *buf);
 205 char *           edit_uint64             (uint64_t val, char *buf);
 206 char *           edit_int64              (int64_t val, char *buf);
 207 char *           edit_int64_with_commas  (int64_t val, char *buf);
 208 bool             duration_to_utime       (char *str, utime_t *value);
 209 bool             size_to_uint64(char *str, int str_len, uint64_t *rtn_value);
 210 bool             speed_to_uint64(char *str, int str_len, uint64_t *rtn_value);
 211 char             *edit_utime             (utime_t val, char *buf, int buf_len);
 212 bool             is_a_number             (const char *num);
 213 bool             is_a_number_list        (const char *n);
 214 bool             is_an_integer           (const char *n);
 215 bool             is_name_valid           (const char *name, POOLMEM **msg);
 216
 217 /* jcr.c (most definitions are in src/jcr.h) */
 218 void     init_last_jobs_list();
 219 void     term_last_jobs_list();
 220 void     lock_last_jobs_list();
 221 void     unlock_last_jobs_list();
 222 bool     read_last_jobs_list(int fd, uint64_t addr);
 223 uint64_t write_last_jobs_list(int fd, uint64_t addr);
 224 void     write_state_file(char *dir, const char *progname, int port);
 225 void     job_end_push(JCR *jcr, void job_end_cb(JCR *jcr,void *), void *ctx);
 226 void     lock_jobs();
 227 void     unlock_jobs();
 228 JCR     *jcr_walk_start();
 229 JCR     *jcr_walk_next(JCR *prev_jcr);
 230 void     jcr_walk_end(JCR *jcr);
 231 int      job_count();
 232 JCR     *get_jcr_from_tsd();
 233 void     set_jcr_in_tsd(JCR *jcr);
 234 void     remove_jcr_from_tsd(JCR *jcr);
 235 uint32_t get_jobid_from_tsd();
 236 uint32_t get_jobid_from_tid(pthread_t tid);
 237
 238
 239 /* lex.c */
 240 LEX *     lex_close_file         (LEX *lf);
 241 LEX *     lex_open_file          (LEX *lf, const char *fname, LEX_ERROR_HANDLER *scan_error);
 242 LEX *     lex_open_buf           (LEX *lf, const char *buf, LEX_ERROR_HANDLER *scan_error);
 243 int       lex_get_char           (LEX *lf);
 244 void      lex_unget_char         (LEX *lf);
 245 const char *  lex_tok_to_str     (int token);
 246 int       lex_get_token          (LEX *lf, int expect);
 247 void      lex_set_default_error_handler (LEX *lf);
 248 int       lex_set_error_handler_error_type (LEX *lf, int err_type);
 249 bool      lex_check_eol          (LEX *lf);
 250
 251 /* Required typedef, not in a C file */
 252 extern "C" {
 253    typedef char *(*job_code_callback_t)(JCR *, const char *, char *, int);
 254 }
 255
 256 /* message.c */
 257 void       my_name_is            (int argc, char *argv[], const char *name);
 258 void       init_msg              (JCR *jcr, MSGS *msg, job_code_callback_t job_code_callback = NULL);
 259 void       term_msg              (void);
 260 void       close_msg             (JCR *jcr);
 261 void       add_msg_dest          (MSGS *msg, int dest, int type, char *where, char *dest_code);
 262 void       rem_msg_dest          (MSGS *msg, int dest, int type, char *where);
 263 void       Jmsg                  (JCR *jcr, int type, utime_t mtime, const char *fmt, ...);
 264 void       dispatch_message      (JCR *jcr, int type, utime_t mtime, char *buf);
 265 void       init_console_msg      (const char *wd);
 266 void       free_msgs_res         (MSGS *msgs);
 267 void       dequeue_messages      (JCR *jcr);
 268 void       set_db_engine_name    (const char *name);
 269 void       set_trace             (int trace_flag);
 270 bool       get_trace             (void);
 271 void       set_hangup            (int hangup_value);
 272 void       set_blowup            (int blowup_value);
 273 int        get_hangup            (void);
 274 int        get_blowup            (void);
 275 bool       handle_hangup_blowup  (JCR *jcr, uint32_t file_count, uint64_t byte_count);
 276 void       set_assert_msg        (const char *file, int line, const char *msg);
 277 void       register_message_callback(void msg_callback(int type, char *msg));
 278
 279 /* bnet_server.c */
 280 void       bnet_thread_server(dlist *addr_list, int max_clients,
 281               workq_t *client_wq, void *handle_client_request(void *bsock));
 282 void       bnet_stop_thread_server(pthread_t tid);
 283 void             bnet_server             (int port, void handle_client_request(BSOCK *bsock));
 284 int              net_connect             (int port);
 285 BSOCK *          bnet_bind               (int port);
 286 BSOCK *          bnet_accept             (BSOCK *bsock, char *who);
 287
 288 /* message.c */
 289 typedef int (EVENT_HANDLER)(JCR *jcr, const char *event);
 290 int generate_daemon_event(JCR *jcr, const char *event);
 291
 292 /* signal.c */
 293 void             init_signals             (void terminate(int sig));
 294 void             init_stack_dump          (void);
 295
 296 /* Used to display specific job information after a fatal signal */
 297 typedef void (dbg_hook_t)(FILE *fp);
 298 void dbg_add_hook(dbg_hook_t *fct);
 299
 300 /* scan.c */
 301 void             strip_leading_space     (char *str);
 302 char            *strip_trailing_junk     (char *str);
 303 char            *strip_trailing_newline  (char *str);
 304 char            *strip_trailing_slashes  (char *dir);
 305 bool             skip_spaces             (char **msg);
 306 bool             skip_nonspaces          (char **msg);
 307 int              fstrsch                 (const char *a, const char *b);
 308 char            *next_arg(char **s);
 309 int              parse_args(POOLMEM *cmd, POOLMEM **args, int *argc,
 310                         char **argk, char **argv, int max_args);
 311 int              parse_args_only(POOLMEM *cmd, POOLMEM **args, int *argc,
 312                         char **argk, char **argv, int max_args);
 313 void            split_path_and_filename(const char *fname, POOLMEM **path,
 314                         int *pnl, POOLMEM **file, int *fnl);
 315 int             bsscanf(const char *buf, const char *fmt, ...);
 316
 317
 318 /* tls.c */
 319 TLS_CONTEXT      *new_tls_context        (const char *ca_certfile,
 320                                           const char *ca_certdir,
 321                                           const char *certfile,
 322                                           const char *keyfile,
 323                                           CRYPTO_PEM_PASSWD_CB *pem_callback,
 324                                           const void *pem_userdata,
 325                                           const char *dhfile,
 326                                           bool verify_peer);
 327 void             free_tls_context        (TLS_CONTEXT *ctx);
 328 #ifdef HAVE_TLS
 329 bool             tls_postconnect_verify_host(JCR *jcr, TLS_CONNECTION *tls,
 330                                                const char *host);
 331 bool             tls_postconnect_verify_cn(JCR *jcr, TLS_CONNECTION *tls,
 332                                                alist *verify_list);
 333 TLS_CONNECTION   *new_tls_connection     (TLS_CONTEXT *ctx, int fd);
 334 bool             tls_bsock_accept        (BSOCK *bsock);
 335 int              tls_bsock_writen        (BSOCK *bsock, char *ptr, int32_t nbytes);
 336 int              tls_bsock_readn         (BSOCK *bsock, char *ptr, int32_t nbytes);
 337 bool             tls_bsock_probe         (BSOCK *bsock);
 338 #endif /* HAVE_TLS */
 339 bool             tls_bsock_connect       (BSOCK *bsock);
 340 void             tls_bsock_shutdown      (BSOCK *bsock);
 341 void             free_tls_connection     (TLS_CONNECTION *tls);
 342 bool             get_tls_require         (TLS_CONTEXT *ctx);
 343 bool             get_tls_enable          (TLS_CONTEXT *ctx);
 344
 345
 346 /* util.c */
 347 void             bmemzero                (void *buf, size_t size);
 348 bool             is_null                 (const void *ptr);
 349 bool             is_buf_zero             (const char *buf, int len);
 350 void             lcase                   (char *str);
 351 void             bash_spaces             (char *str);
 352 void             bash_spaces             (POOL_MEM &pm);
 353 void             unbash_spaces           (char *str);
 354 void             unbash_spaces           (POOL_MEM &pm);
 355 char *           encode_time             (utime_t time, char *buf);
 356 char *           encode_mode             (mode_t mode, char *buf);
 357 char *           hexdump(const char *data, int len, char *buf, int capacity, bool add_spaces=true);
 358 char *           asciidump(const char *data, int len, char *buf, int capacity);
 359 char *           smartdump(const char *data, int len, char *buf, int capacity, bool *is_ascii=NULL);
 360 int              is_power_of_two         (uint64_t x);
 361 int              do_shell_expansion      (char *name, int name_len);
 362 void             jobstatus_to_ascii      (int JobStatus, char *msg, int maxlen);
 363 void             jobstatus_to_ascii_gui  (int JobStatus, char *msg, int maxlen);
 364 int              run_program             (char *prog, int wait, POOLMEM *&results);
 365 int              run_program_full_output (char *prog, int wait, POOLMEM *&results, char *env[]=NULL);
 366 char *           action_on_purge_to_string(int aop, POOL_MEM &ret);
 367 const char *     job_type_to_str         (int type);
 368 const char *     job_status_to_str       (int stat, int errors);
 369 const char *     job_level_to_str        (int level);
 370 const char *     volume_status_to_str    (const char *status);
 371 void             make_session_key        (char *key, char *seed, int mode);
 372 void             encode_session_key      (char *encode, char *session, char *key, int maxlen);
 373 void             decode_session_key      (char *decode, char *session, char *key, int maxlen);
 374 POOLMEM *        edit_job_codes          (JCR *jcr, char *omsg, char *imsg, const char *to, job_code_callback_t job_code_callback = NULL);
 375 void             set_working_directory   (char *wd);
 376 const char *     last_path_separator     (const char *str);
 377
 378 /* watchdog.c */
 379 int start_watchdog(void);
 380 int stop_watchdog(void);
 381 watchdog_t *new_watchdog(void);
 382 bool register_watchdog(watchdog_t *wd);
 383 bool unregister_watchdog(watchdog_t *wd);
 384 bool is_watchdog();
 385
 386 /* timers.c */
 387 btimer_t *start_child_timer(JCR *jcr, pid_t pid, uint32_t wait);
 388 void stop_child_timer(btimer_t *wid);
 389 btimer_t *start_thread_timer(JCR *jcr, pthread_t tid, uint32_t wait);
 390 void stop_thread_timer(btimer_t *wid);
 391 btimer_t *start_bsock_timer(BSOCK *bs, uint32_t wait);
 392 void stop_bsock_timer(btimer_t *wid);
 393
 394 #endif /* __LIBPROTOS_H */