git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/protos.h

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