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

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