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, char *bin, int len);
  35
  36 /* bsys.c */
  37 char     *bstrncpy               (char *dest, const char *src, int maxlen);
  38 char     *bstrncpy               (char *dest, POOL_MEM &src, int maxlen);
  39 char     *bstrncat               (char *dest, const char *src, int maxlen);
  40 char     *bstrncat               (char *dest, POOL_MEM &src, int maxlen);
  41 int       cstrlen                (const char *str);
  42 void     *b_malloc               (const char *file, int line, size_t size);
  43 #ifndef DEBUG
  44 void     *bmalloc                (size_t size);
  45 #endif
  46 void     *brealloc               (void *buf, size_t size);
  47 void     *bcalloc                (size_t size1, size_t size2);
  48 int       bsnprintf              (char *str, int32_t size, const char *format, ...);
  49 int       bvsnprintf             (char *str, int32_t size, const char *format, va_list ap);
  50 int       pool_sprintf           (char *pool_buf, const char *fmt, ...);
  51 void      create_pid_file        (char *dir, const char *progname, int port);
  52 int       delete_pid_file        (char *dir, const char *progname, int port);
  53 void      drop                   (char *uid, char *gid);
  54 int       bmicrosleep            (time_t sec, long usec);
  55 char     *bfgets                 (char *s, int size, FILE *fd);
  56 void      make_unique_filename   (POOLMEM **name, int Id, char *what);
  57 #ifndef HAVE_STRTOLL
  58 long long int strtoll            (const char *ptr, char **endptr, int base);
  59 #endif
  60 void      read_state_file(char *dir, const char *progname, int port);
  61 int       bstrerror(int errnum, char *buf, size_t bufsiz);
  62
  63 /* bnet.c */
  64 int32_t    bnet_recv             (BSOCK *bsock);
  65 bool       bnet_send             (BSOCK *bsock);
  66 bool       bnet_fsend            (BSOCK *bs, const char *fmt, ...);
  67 bool       bnet_set_buffer_size  (BSOCK *bs, uint32_t size, int rw);
  68 bool       bnet_sig              (BSOCK *bs, int sig);
  69 int        bnet_tls_server       (TLS_CONTEXT *ctx, BSOCK *bsock,
  70                                   alist *verify_list);
  71 int        bnet_tls_client       (TLS_CONTEXT *ctx, BSOCK *bsock);
  72 BSOCK *    bnet_connect          (JCR *jcr, int retry_interval,
  73                int max_retry_time, const char *name, char *host, char *service,
  74                int port, int verbose);
  75 void       bnet_close            (BSOCK *bsock);
  76 BSOCK *    init_bsock            (JCR *jcr, int sockfd, const char *who, const char *ip,
  77                                   int port, struct sockaddr *client_addr);
  78 BSOCK *    dup_bsock             (BSOCK *bsock);
  79 void       term_bsock            (BSOCK *bsock);
  80 const char *bnet_strerror         (BSOCK *bsock);
  81 const char *bnet_sig_to_ascii     (BSOCK *bsock);
  82 int        bnet_wait_data        (BSOCK *bsock, int sec);
  83 int        bnet_wait_data_intr   (BSOCK *bsock, int sec);
  84 int        bnet_despool_to_bsock (BSOCK *bsock, void update(ssize_t size), ssize_t size);
  85 bool       is_bnet_stop          (BSOCK *bsock);
  86 int        is_bnet_error         (BSOCK *bsock);
  87 void       bnet_suppress_error_messages(BSOCK *bsock, bool flag);
  88 dlist *bnet_host2ipaddrs(const char *host, int family, const char **errstr);
  89 int        bnet_set_blocking     (BSOCK *sock);
  90 int        bnet_set_nonblocking  (BSOCK *sock);
  91 void       bnet_restore_blocking (BSOCK *sock, int flags);
  92
  93 /* bget_msg.c */
  94 int      bget_msg(BSOCK *sock);
  95
  96 /* bpipe.c */
  97 BPIPE *          open_bpipe(char *prog, int wait, const char *mode);
  98 int              close_wpipe(BPIPE *bpipe);
  99 int              close_bpipe(BPIPE *bpipe);
 100
 101 /* cram-md5.c */
 102 int cram_md5_get_auth(BSOCK *bs, char *password, int *tls_remote_need);
 103 int cram_md5_auth(BSOCK *bs, char *password, int tls_local_need);
 104 void hmac_md5(uint8_t* text, int text_len, uint8_t*  key,
 105               int key_len, uint8_t *hmac);
 106
 107 /* crc32.c */
 108
 109 uint32_t bcrc32(uint8_t *buf, int len);
 110
 111 /* crypto.c */
 112 int                init_crypto                 (void);
 113 int                cleanup_crypto              (void);
 114 DIGEST *           crypto_digest_new           (crypto_digest_t type);
 115 bool               crypto_digest_update        (DIGEST *digest, const void *data, size_t length);
 116 bool               crypto_digest_finalize      (DIGEST *digest, void *dest, size_t *length);
 117 void               crypto_digest_free          (DIGEST *digest);
 118 SIGNATURE *        crypto_sign_new             (void);
 119 crypto_error_t     crypto_sign_get_digest      (SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST **digest);
 120 crypto_error_t     crypto_sign_verify          (SIGNATURE *sig, X509_KEYPAIR *keypair, DIGEST *digest);
 121 int                crypto_sign_add_signer      (SIGNATURE *sig, DIGEST *digest, X509_KEYPAIR *keypair);
 122 int                crypto_sign_encode          (SIGNATURE *sig, void *dest, size_t *length);
 123 SIGNATURE *        crypto_sign_decode          (const void *sigData, size_t length);
 124 void               crypto_sign_free            (SIGNATURE *sig);
 125 CRYPTO_SESSION *   crypto_session_new          (crypto_cipher_t cipher, alist *pubkeys);
 126 void               crypto_session_free         (CRYPTO_SESSION *cs);
 127 bool               crypto_session_encode       (CRYPTO_SESSION *cs, void *dest, size_t *length);
 128 crypto_error_t     crypto_session_decode       (const void *data, size_t length, alist *keypairs, CRYPTO_SESSION **session);
 129 CRYPTO_SESSION *   crypto_session_decode       (const void *data, size_t length);
 130 CIPHER_CONTEXT *   crypto_cipher_new           (CRYPTO_SESSION *cs, bool encrypt, size_t *blocksize);
 131 bool               crypto_cipher_update        (CIPHER_CONTEXT *cipher_ctx, const void *data, size_t length, const void *dest, size_t *written);
 132 bool               crypto_cipher_finalize      (CIPHER_CONTEXT *cipher_ctx, void *dest, size_t *written);
 133 void               crypto_cipher_free          (CIPHER_CONTEXT *cipher_ctx);
 134 X509_KEYPAIR *     crypto_keypair_new          (void);
 135 X509_KEYPAIR *     crypto_keypair_dup          (X509_KEYPAIR *keypair);
 136 int                crypto_keypair_load_cert    (X509_KEYPAIR *keypair, const char *file);
 137 bool               crypto_keypair_has_key      (const char *file);
 138 int                crypto_keypair_load_key     (X509_KEYPAIR *keypair, const char *file, CRYPTO_PEM_PASSWD_CB *pem_callback, const void *pem_userdata);
 139 void               crypto_keypair_free         (X509_KEYPAIR *keypair);
 140 int                crypto_default_pem_callback (char *buf, int size, const void *userdata);
 141 const char *       crypto_digest_name          (DIGEST *digest);
 142 crypto_digest_t    crypto_digest_stream_type   (int stream);
 143 const char *       crypto_strerror             (crypto_error_t error);
 144
 145 /* daemon.c */
 146 void     daemon_start            ();
 147
 148 /* edit.c */
 149 uint64_t         str_to_uint64(char *str);
 150 int64_t          str_to_int64(char *str);
 151 #define str_to_int32(str) ((int32_t)str_to_int64(str))
 152 char *           edit_uint64_with_commas   (uint64_t val, char *buf);
 153 char *           edit_uint64_with_suffix   (uint64_t val, char *buf);
 154 char *           add_commas              (char *val, char *buf);
 155 char *           edit_uint64             (uint64_t val, char *buf);
 156 char *           edit_int64              (int64_t val, char *buf);
 157 bool             duration_to_utime       (char *str, utime_t *value);
 158 bool             size_to_uint64(char *str, int str_len, uint64_t *rtn_value);
 159 char             *edit_utime             (utime_t val, char *buf, int buf_len);
 160 bool             is_a_number             (const char *num);
 161 bool             is_an_integer           (const char *n);
 162 bool             is_name_valid           (char *name, POOLMEM **msg);
 163
 164 /* jcr.c (most definitions are in src/jcr.h) */
 165 void init_last_jobs_list();
 166 void term_last_jobs_list();
 167 void lock_last_jobs_list();
 168 void unlock_last_jobs_list();
 169 bool read_last_jobs_list(int fd, uint64_t addr);
 170 uint64_t write_last_jobs_list(int fd, uint64_t addr);
 171 void write_state_file(char *dir, const char *progname, int port);
 172 void job_end_push(JCR *jcr, void job_end_cb(JCR *jcr,void *), void *ctx);
 173 void lock_jobs();
 174 void unlock_jobs();
 175 JCR *jcr_walk_start();
 176 JCR *jcr_walk_next(JCR *prev_jcr);
 177 void jcr_walk_end(JCR *jcr);
 178
 179
 180 /* lex.c */
 181 LEX *     lex_close_file         (LEX *lf);
 182 LEX *     lex_open_file          (LEX *lf, const char *fname, LEX_ERROR_HANDLER *scan_error);
 183 int       lex_get_char           (LEX *lf);
 184 void      lex_unget_char         (LEX *lf);
 185 const char *  lex_tok_to_str     (int token);
 186 int       lex_get_token          (LEX *lf, int expect);
 187 void      lex_set_default_error_handler (LEX *lf);
 188
 189 /* message.c */
 190 void       my_name_is            (int argc, char *argv[], const char *name);
 191 void       init_msg              (JCR *jcr, MSGS *msg);
 192 void       term_msg              (void);
 193 void       close_msg             (JCR *jcr);
 194 void       add_msg_dest          (MSGS *msg, int dest, int type, char *where, char *dest_code);
 195 void       rem_msg_dest          (MSGS *msg, int dest, int type, char *where);
 196 void       Jmsg                  (JCR *jcr, int type, time_t mtime, const char *fmt, ...);
 197 void       dispatch_message      (JCR *jcr, int type, time_t mtime, char *buf);
 198 void       init_console_msg      (const char *wd);
 199 void       free_msgs_res         (MSGS *msgs);
 200 void       dequeue_messages      (JCR *jcr);
 201 void       set_trace             (int trace_flag);
 202
 203 /* bnet_server.c */
 204 void       bnet_thread_server(dlist *addr, int max_clients, workq_t *client_wq,
 205                    void *handle_client_request(void *bsock));
 206 void       bnet_stop_thread_server(pthread_t tid);
 207 void             bnet_server             (int port, void handle_client_request(BSOCK *bsock));
 208 int              net_connect             (int port);
 209 BSOCK *          bnet_bind               (int port);
 210 BSOCK *          bnet_accept             (BSOCK *bsock, char *who);
 211
 212 /* idcache.c */
 213 char *getuser(uid_t uid);
 214 void free_getuser_cache();
 215 char *getgroup (gid_t gid);
 216 void free_getgroup_cache();
 217
 218 /* python.c */
 219 typedef int (EVENT_HANDLER)(JCR *jcr, const char *event);
 220 void init_python_interpreter(const char *progname, const char *scripts,
 221                              const char *module);
 222 void term_python_interpreter();
 223 //extern EVENT_HANDLER *generate_daemon_event;
 224 int generate_daemon_event(JCR *jcr, const char *event);
 225 void lock_python();
 226 void unlock_python();
 227
 228 /* signal.c */
 229 void             init_signals             (void terminate(int sig));
 230 void             init_stack_dump          (void);
 231
 232 /* scan.c */
 233 void             strip_leading_space     (char *str);
 234 void             strip_trailing_junk     (char *str);
 235 void             strip_trailing_newline  (char *str);
 236
 237 void             strip_trailing_slashes  (char *dir);
 238 bool             skip_spaces             (char **msg);
 239 bool             skip_nonspaces          (char **msg);
 240 int              fstrsch                 (const char *a, const char *b);
 241 char            *next_arg(char **s);
 242 int              parse_args(POOLMEM *cmd, POOLMEM **args, int *argc,
 243                         char **argk, char **argv, int max_args);
 244 void            split_path_and_filename(const char *fname, POOLMEM **path,
 245                         int *pnl, POOLMEM **file, int *fnl);
 246 int             bsscanf(const char *buf, const char *fmt, ...);
 247
 248
 249 /* tls.c */
 250 TLS_CONTEXT      *new_tls_context        (const char *ca_certfile,
 251                                           const char *ca_certdir,
 252                                           const char *certfile,
 253                                           const char *keyfile,
 254                                           CRYPTO_PEM_PASSWD_CB *pem_callback,
 255                                           const void *pem_userdata,
 256                                           const char *dhfile,
 257                                           bool verify_peer);
 258 void             free_tls_context        (TLS_CONTEXT *ctx);
 259 #ifdef HAVE_TLS
 260 bool             tls_postconnect_verify_host  (TLS_CONNECTION *tls,
 261                                                const char *host);
 262 bool             tls_postconnect_verify_cn    (TLS_CONNECTION *tls,
 263                                                alist *verify_list);
 264 TLS_CONNECTION   *new_tls_connection     (TLS_CONTEXT *ctx, int fd);
 265 void             free_tls_connection     (TLS_CONNECTION *tls);
 266 bool             tls_bsock_connect       (BSOCK *bsock);
 267 bool             tls_bsock_accept        (BSOCK *bsock);
 268 void             tls_bsock_shutdown      (BSOCK *bsock);
 269 int              tls_bsock_writen        (BSOCK *bsock, char *ptr, int32_t nbytes);
 270 int              tls_bsock_readn         (BSOCK *bsock, char *ptr, int32_t nbytes);
 271 #endif /* HAVE_TLS */
 272
 273
 274 /* util.c */
 275 int              is_buf_zero             (char *buf, int len);
 276 void             lcase                   (char *str);
 277 void             bash_spaces             (char *str);
 278 void             bash_spaces             (POOL_MEM &pm);
 279 void             unbash_spaces           (char *str);
 280 void             unbash_spaces           (POOL_MEM &pm);
 281 char *           encode_time             (time_t time, char *buf);
 282 char *           encode_mode             (mode_t mode, char *buf);
 283 int              do_shell_expansion      (char *name, int name_len);
 284 void             jobstatus_to_ascii      (int JobStatus, char *msg, int maxlen);
 285 int              run_program             (char *prog, int wait, POOLMEM *results);
 286 int              run_program_full_output (char *prog, int wait, POOLMEM *results);
 287 const char *     job_type_to_str         (int type);
 288 const char *     job_status_to_str       (int stat);
 289 const char *     job_level_to_str        (int level);
 290 void             make_session_key        (char *key, char *seed, int mode);
 291 POOLMEM         *edit_job_codes(JCR *jcr, char *omsg, char *imsg, const char *to);
 292 void             set_working_directory(char *wd);
 293
 294
 295 /* watchdog.c */
 296 int start_watchdog(void);
 297 int stop_watchdog(void);
 298 watchdog_t *new_watchdog(void);
 299 bool register_watchdog(watchdog_t *wd);
 300 bool unregister_watchdog(watchdog_t *wd);
 301
 302 /* timers.c */
 303 btimer_t *start_child_timer(pid_t pid, uint32_t wait);
 304 void stop_child_timer(btimer_t *wid);
 305 btimer_t *start_thread_timer(pthread_t tid, uint32_t wait);
 306 void stop_thread_timer(btimer_t *wid);
 307 btimer_t *start_bsock_timer(BSOCK *bs, uint32_t wait);
 308 void stop_bsock_timer(btimer_t *wid);