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