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

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