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

   1 /*
   2  * Prototypes for lib directory of Bacula
   3  *
   4  *   Version $Id$
   5  */
   6 /*
   7    Copyright (C) 2000-2006 Kern Sibbald
   8
   9    This program is free software; you can redistribute it and/or
  10    modify it under the terms of the GNU General Public License
  11    version 2 as amended with additional clauses defined in the
  12    file LICENSE in the main source directory.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17    the file LICENSE for additional details.
  18
  19  */
  20
  21 class JCR;
  22
  23 /* attr.c */
  24 ATTR     *new_attr();
  25 void      free_attr(ATTR *attr);
  26 int       unpack_attributes_record(JCR *jcr, int32_t stream, char *rec, ATTR *attr);
  27 void      build_attr_output_fnames(JCR *jcr, ATTR *attr);
  28 void      print_ls_output(JCR *jcr, ATTR *attr);
  29
  30 /* base64.c */
  31 void      base64_init            (void);
  32 int       to_base64              (intmax_t value, char *where);
  33 int       from_base64            (intmax_t *value, char *where);
  34 int       bin_to_base64          (char *buf, int buflen, char *bin, int binlen,
  35                                   int compatible);
  36
  37 /* bsys.c */
  38 char     *bstrncpy               (char *dest, const char *src, int maxlen);
  39 char     *bstrncpy               (char *dest, POOL_MEM &src, int maxlen);
  40 char     *bstrncat               (char *dest, const char *src, int maxlen);
  41 char     *bstrncat               (char *dest, POOL_MEM &src, int maxlen);
  42 bool      bstrcmp                (const char *s1, const char *s2);
  43 int       cstrlen                (const char *str);
  44 void     *b_malloc               (const char *file, int line, size_t size);
  45 #ifndef bmalloc
  46 void     *bmalloc                (size_t size);
  47 #endif
  48 void      bfree                  (void *buf);
  49 void     *brealloc               (void *buf, size_t size);
  50 void     *bcalloc                (size_t size1, size_t size2);
  51 int       bsnprintf              (char *str, int32_t size, const char *format, ...);
  52 int       bvsnprintf             (char *str, int32_t size, const char *format, va_list ap);
  53 int       pool_sprintf           (char *pool_buf, const char *fmt, ...);
  54 void      create_pid_file        (char *dir, const char *progname, int port);
  55 int       delete_pid_file        (char *dir, const char *progname, int port);
  56 void      drop                   (char *uid, char *gid);
  57 int       bmicrosleep            (time_t sec, long usec);
  58 char     *bfgets                 (char *s, int size, FILE *fd);
  59 void      make_unique_filename   (POOLMEM **name, int Id, char *what);
  60 #ifndef HAVE_STRTOLL
  61 long long int strtoll            (const char *ptr, char **endptr, int base);
  62 #endif
  63 void      read_state_file(char *dir, const char *progname, int port);
  64 int       bstrerror(int errnum, char *buf, size_t bufsiz);
  65 char     *escape_filename(const char *file_path);
  66
  67 /* bnet.c */
  68 int32_t    bnet_recv             (BSOCK *bsock);
  69 bool       bnet_send             (BSOCK *bsock);
  70 bool       bnet_fsend            (BSOCK *bs, const char *fmt, ...);
  71 bool       bnet_set_buffer_size  (BSOCK *bs, uint32_t size, int rw);
  72 bool       bnet_sig              (BSOCK *bs, int sig);
  73 bool       bnet_tls_server       (TLS_CONTEXT *ctx, BSOCK *bsock,
  74                                   alist *verify_list);
  75 bool       bnet_tls_client       (TLS_CONTEXT *ctx, BSOCK *bsock);
  76 BSOCK *    bnet_connect          (JCR *jcr, int retry_interval,
  77                int max_retry_time, const char *name, char *host, char *service,
  78                int port, int verbose);
  79 void       bnet_close            (BSOCK *bsock);
  80 BSOCK *    init_bsock            (JCR *jcr, int sockfd, const char *who, const char *ip,
  81                                   int port, struct sockaddr *client_addr);
  82 #ifdef HAVE_WIN32
  83 #ifndef socklen_t
  84 #define socklen_t int
  85 #endif
  86 #endif
  87 int        bnet_get_peer           (BSOCK *bs, char *buf, socklen_t buflen);
  88 BSOCK *    dup_bsock             (BSOCK *bsock);
  89 void       term_bsock            (BSOCK *bsock);
  90 const char *bnet_strerror         (BSOCK *bsock);
  91 const char *bnet_sig_to_ascii     (BSOCK *bsock);
  92 int        bnet_wait_data        (BSOCK *bsock, int sec);
  93 int        bnet_wait_data_intr   (BSOCK *bsock, int sec);
  94 int        bnet_despool_to_bsock (BSOCK *bsock, void update(ssize_t size), ssize_t size);
  95 bool       is_bnet_stop          (BSOCK *bsock);
  96 int        is_bnet_error         (BSOCK *bsock);
  97 void       bnet_suppress_error_messages(BSOCK *bsock, bool flag);
  98 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr);
  99 int        bnet_set_blocking     (BSOCK *sock);
 100 int        bnet_set_nonblocking  (BSOCK *sock);
 101 void       bnet_restore_blocking (BSOCK *sock, int flags);
 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, char *password, int *tls_remote_need, int *compatible);
 113 bool cram_md5_challenge(BSOCK *bs, 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           (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             (void);
 128 crypto_error_t     crypto_sign_get_digest      (SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST **digest);
 129 crypto_error_t     crypto_sign_verify          (SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest);
 130 int                crypto_sign_add_signer      (SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair);
 131 int                crypto_sign_encode          (SIGNATURE *sig, uint8_t *dest, uint32_t *length);
 132 SIGNATURE *        crypto_sign_decode          (const uint8_t *sigData, uint32_t length);
 133 void               crypto_sign_free            (SIGNATURE *sig);
 134 CRYPTO_SESSION *   crypto_session_new          (crypto_cipher_t cipher, alist *pubkeys);
 135 void               crypto_session_free         (CRYPTO_SESSION *cs);
 136 bool               crypto_session_encode       (CRYPTO_SESSION *cs, uint8_t *dest, uint32_t *length);
 137 crypto_error_t     crypto_session_decode       (const uint8_t *data, uint32_t length, alist *keypairs, CRYPTO_SESSION **session);
 138 CRYPTO_SESSION *   crypto_session_decode       (const uint8_t *data, uint32_t length);
 139 CIPHER_CONTEXT *   crypto_cipher_new           (CRYPTO_SESSION *cs, bool encrypt, uint32_t *blocksize);
 140 bool               crypto_cipher_update        (CIPHER_CONTEXT *cipher_ctx, const uint8_t *data, uint32_t length, const uint8_t *dest, uint32_t *written);
 141 bool               crypto_cipher_finalize      (CIPHER_CONTEXT *cipher_ctx, uint8_t *dest, uint32_t *written);
 142 void               crypto_cipher_free          (CIPHER_CONTEXT *cipher_ctx);
 143 X509_KEYPAIR *     crypto_keypair_new          (void);
 144 X509_KEYPAIR *     crypto_keypair_dup          (X509_KEYPAIR *keypair);
 145 int                crypto_keypair_load_cert    (X509_KEYPAIR *keypair, const char *file);
 146 bool               crypto_keypair_has_key      (const char *file);
 147 int                crypto_keypair_load_key     (X509_KEYPAIR *keypair, const char *file, CRYPTO_PEM_PASSWD_CB *pem_callback, const void *pem_userdata);
 148 void               crypto_keypair_free         (X509_KEYPAIR *keypair);
 149 int                crypto_default_pem_callback (char *buf, int size, const void *userdata);
 150 const char *       crypto_digest_name          (DIGEST *digest);
 151 crypto_digest_t    crypto_digest_stream_type   (int stream);
 152 const char *       crypto_strerror             (crypto_error_t error);
 153
 154 /* daemon.c */
 155 void     daemon_start            ();
 156
 157 /* edit.c */
 158 uint64_t         str_to_uint64(char *str);
 159 int64_t          str_to_int64(char *str);
 160 #define str_to_int32(str) ((int32_t)str_to_int64(str))
 161 char *           edit_uint64_with_commas   (uint64_t val, char *buf);
 162 char *           edit_uint64_with_suffix   (uint64_t val, char *buf);
 163 char *           add_commas              (char *val, char *buf);
 164 char *           edit_uint64             (uint64_t val, char *buf);
 165 char *           edit_int64              (int64_t val, char *buf);
 166 bool             duration_to_utime       (char *str, utime_t *value);
 167 bool             size_to_uint64(char *str, int str_len, uint64_t *rtn_value);
 168 char             *edit_utime             (utime_t val, char *buf, int buf_len);
 169 bool             is_a_number             (const char *num);
 170 bool             is_an_integer           (const char *n);
 171 bool             is_name_valid           (char *name, POOLMEM **msg);
 172
 173 /* jcr.c (most definitions are in src/jcr.h) */
 174 void init_last_jobs_list();
 175 void term_last_jobs_list();
 176 void lock_last_jobs_list();
 177 void unlock_last_jobs_list();
 178 bool read_last_jobs_list(int fd, uint64_t addr);
 179 uint64_t write_last_jobs_list(int fd, uint64_t addr);
 180 void write_state_file(char *dir, const char *progname, int port);
 181 void job_end_push(JCR *jcr, void job_end_cb(JCR *jcr,void *), void *ctx);
 182 void lock_jobs();
 183 void unlock_jobs();
 184 JCR *jcr_walk_start();
 185 JCR *jcr_walk_next(JCR *prev_jcr);
 186 void jcr_walk_end(JCR *jcr);
 187
 188
 189 /* lex.c */
 190 LEX *     lex_close_file         (LEX *lf);
 191 LEX *     lex_open_file          (LEX *lf, const char *fname, LEX_ERROR_HANDLER *scan_error);
 192 int       lex_get_char           (LEX *lf);
 193 void      lex_unget_char         (LEX *lf);
 194 const char *  lex_tok_to_str     (int token);
 195 int       lex_get_token          (LEX *lf, int expect);
 196 void      lex_set_default_error_handler (LEX *lf);
 197 int       lex_set_error_handler_error_type (LEX *lf, int err_type);
 198
 199 /* message.c */
 200 void       my_name_is            (int argc, char *argv[], const char *name);
 201 void       init_msg              (JCR *jcr, MSGS *msg);
 202 void       term_msg              (void);
 203 void       close_msg             (JCR *jcr);
 204 void       add_msg_dest          (MSGS *msg, int dest, int type, char *where, char *dest_code);
 205 void       rem_msg_dest          (MSGS *msg, int dest, int type, char *where);
 206 void       Jmsg                  (JCR *jcr, int type, time_t mtime, const char *fmt, ...);
 207 void       dispatch_message      (JCR *jcr, int type, time_t mtime, char *buf);
 208 void       init_console_msg      (const char *wd);
 209 void       free_msgs_res         (MSGS *msgs);
 210 void       dequeue_messages      (JCR *jcr);
 211 void       set_trace             (int trace_flag);
 212
 213 /* bnet_server.c */
 214 void       bnet_thread_server(dlist *addr, int max_clients, workq_t *client_wq,
 215                    void *handle_client_request(void *bsock));
 216 void       bnet_stop_thread_server(pthread_t tid);
 217 void             bnet_server             (int port, void handle_client_request(BSOCK *bsock));
 218 int              net_connect             (int port);
 219 BSOCK *          bnet_bind               (int port);
 220 BSOCK *          bnet_accept             (BSOCK *bsock, char *who);
 221
 222 /* idcache.c */
 223 char *getuser(uid_t uid);
 224 void free_getuser_cache();
 225 char *getgroup (gid_t gid);
 226 void free_getgroup_cache();
 227
 228 /* python.c */
 229 typedef int (EVENT_HANDLER)(JCR *jcr, const char *event);
 230 void init_python_interpreter(const char *progname, const char *scripts,
 231                              const char *module);
 232 void term_python_interpreter();
 233 //extern EVENT_HANDLER *generate_daemon_event;
 234 int generate_daemon_event(JCR *jcr, const char *event);
 235 void lock_python();
 236 void unlock_python();
 237
 238 /* signal.c */
 239 void             init_signals             (void terminate(int sig));
 240 void             init_stack_dump          (void);
 241
 242 /* scan.c */
 243 void             strip_leading_space     (char *str);
 244 void             strip_trailing_junk     (char *str);
 245 void             strip_trailing_newline  (char *str);
 246
 247 void             strip_trailing_slashes  (char *dir);
 248 bool             skip_spaces             (char **msg);
 249 bool             skip_nonspaces          (char **msg);
 250 int              fstrsch                 (const char *a, const char *b);
 251 char            *next_arg(char **s);
 252 int              parse_args(POOLMEM *cmd, POOLMEM **args, int *argc,
 253                         char **argk, char **argv, int max_args);
 254 void            split_path_and_filename(const char *fname, POOLMEM **path,
 255                         int *pnl, POOLMEM **file, int *fnl);
 256 int             bsscanf(const char *buf, const char *fmt, ...);
 257
 258
 259 /* tls.c */
 260 TLS_CONTEXT      *new_tls_context        (const char *ca_certfile,
 261                                           const char *ca_certdir,
 262                                           const char *certfile,
 263                                           const char *keyfile,
 264                                           CRYPTO_PEM_PASSWD_CB *pem_callback,
 265                                           const void *pem_userdata,
 266                                           const char *dhfile,
 267                                           bool verify_peer);
 268 void             free_tls_context        (TLS_CONTEXT *ctx);
 269 #ifdef HAVE_TLS
 270 bool             tls_postconnect_verify_host  (TLS_CONNECTION *tls,
 271                                                const char *host);
 272 bool             tls_postconnect_verify_cn    (TLS_CONNECTION *tls,
 273                                                alist *verify_list);
 274 TLS_CONNECTION   *new_tls_connection     (TLS_CONTEXT *ctx, int fd);
 275 void             free_tls_connection     (TLS_CONNECTION *tls);
 276 bool             tls_bsock_connect       (BSOCK *bsock);
 277 bool             tls_bsock_accept        (BSOCK *bsock);
 278 void             tls_bsock_shutdown      (BSOCK *bsock);
 279 int              tls_bsock_writen        (BSOCK *bsock, char *ptr, int32_t nbytes);
 280 int              tls_bsock_readn         (BSOCK *bsock, char *ptr, int32_t nbytes);
 281 #endif /* HAVE_TLS */
 282
 283
 284 /* util.c */
 285 int              is_buf_zero             (char *buf, int len);
 286 void             lcase                   (char *str);
 287 void             bash_spaces             (char *str);
 288 void             bash_spaces             (POOL_MEM &pm);
 289 void             unbash_spaces           (char *str);
 290 void             unbash_spaces           (POOL_MEM &pm);
 291 char *           encode_time             (time_t time, char *buf);
 292 char *           encode_mode             (mode_t mode, char *buf);
 293 int              do_shell_expansion      (char *name, int name_len);
 294 void             jobstatus_to_ascii      (int JobStatus, char *msg, int maxlen);
 295 int              run_program             (char *prog, int wait, POOLMEM *results);
 296 int              run_program_full_output (char *prog, int wait, POOLMEM *results);
 297 const char *     job_type_to_str         (int type);
 298 const char *     job_status_to_str       (int stat);
 299 const char *     job_level_to_str        (int level);
 300 void             make_session_key        (char *key, char *seed, int mode);
 301 POOLMEM         *edit_job_codes(JCR *jcr, char *omsg, char *imsg, const char *to);
 302 void             set_working_directory(char *wd);
 303
 304
 305 /* watchdog.c */
 306 int start_watchdog(void);
 307 int stop_watchdog(void);
 308 watchdog_t *new_watchdog(void);
 309 bool register_watchdog(watchdog_t *wd);
 310 bool unregister_watchdog(watchdog_t *wd);
 311
 312 /* timers.c */
 313 btimer_t *start_child_timer(pid_t pid, uint32_t wait);
 314 void stop_child_timer(btimer_t *wid);
 315 btimer_t *start_thread_timer(pthread_t tid, uint32_t wait);
 316 void stop_thread_timer(btimer_t *wid);
 317 btimer_t *start_bsock_timer(BSOCK *bs, uint32_t wait);
 318 void stop_bsock_timer(btimer_t *wid);