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