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 /* daemon.c */
 112 void     daemon_start            ();
 113
 114 /* edit.c */
 115 uint64_t         str_to_uint64(char *str);
 116 int64_t          str_to_int64(char *str);
 117 #define          str_to_int32(str) ((int32_t)str_to_int64(str))
 118 char *           edit_uint64_with_suffix   (uint64_t val, char *buf);
 119 char *           edit_uint64_with_commas   (uint64_t val, char *buf);
 120 char *           add_commas              (char *val, char *buf);
 121 char *           edit_uint64             (uint64_t val, char *buf);
 122 char *           edit_int64              (int64_t val, char *buf);
 123 bool             duration_to_utime       (char *str, utime_t *value);
 124 bool             size_to_uint64(char *str, int str_len, uint64_t *rtn_value);
 125 char             *edit_utime             (utime_t val, char *buf, int buf_len);
 126 bool             is_a_number             (const char *num);
 127 bool             is_an_integer           (const char *n);
 128 bool             is_name_valid           (char *name, POOLMEM **msg);
 129
 130 /* jcr.c (most definitions are in src/jcr.h) */
 131 void init_last_jobs_list();
 132 void term_last_jobs_list();
 133 void lock_last_jobs_list();
 134 void unlock_last_jobs_list();
 135 bool read_last_jobs_list(int fd, uint64_t addr);
 136 uint64_t write_last_jobs_list(int fd, uint64_t addr);
 137 void write_state_file(char *dir, const char *progname, int port);
 138 void job_end_push(JCR *jcr, void job_end_cb(JCR *jcr,void *), void *ctx);
 139 void lock_jobs();
 140 void unlock_jobs();
 141 JCR *jcr_walk_start();
 142 JCR *jcr_walk_next(JCR *prev_jcr);
 143 void jcr_walk_end(JCR *jcr);
 144
 145
 146 /* lex.c */
 147 LEX *     lex_close_file         (LEX *lf);
 148 LEX *     lex_open_file          (LEX *lf, const char *fname, LEX_ERROR_HANDLER *scan_error);
 149 int       lex_get_char           (LEX *lf);
 150 void      lex_unget_char         (LEX *lf);
 151 const char *  lex_tok_to_str     (int token);
 152 int       lex_get_token          (LEX *lf, int expect);
 153 void      lex_set_default_error_handler (LEX *lf);
 154 int       lex_set_error_handler_error_type (LEX *lf, int err_type);
 155
 156 /* message.c */
 157 void       my_name_is            (int argc, char *argv[], const char *name);
 158 void       init_msg              (JCR *jcr, MSGS *msg);
 159 void       term_msg              (void);
 160 void       close_msg             (JCR *jcr);
 161 void       add_msg_dest          (MSGS *msg, int dest, int type, char *where, char *dest_code);
 162 void       rem_msg_dest          (MSGS *msg, int dest, int type, char *where);
 163 void       Jmsg                  (JCR *jcr, int type, time_t mtime, const char *fmt, ...);
 164 void       dispatch_message      (JCR *jcr, int type, time_t mtime, char *buf);
 165 void       init_console_msg      (const char *wd);
 166 void       free_msgs_res         (MSGS *msgs);
 167 void       dequeue_messages      (JCR *jcr);
 168 void       set_trace             (int trace_flag);
 169
 170 /* bnet_server.c */
 171 void       bnet_thread_server(dlist *addr, int max_clients, workq_t *client_wq,
 172                    void *handle_client_request(void *bsock));
 173 void       bnet_stop_thread_server(pthread_t tid);
 174 void             bnet_server             (int port, void handle_client_request(BSOCK *bsock));
 175 int              net_connect             (int port);
 176 BSOCK *          bnet_bind               (int port);
 177 BSOCK *          bnet_accept             (BSOCK *bsock, char *who);
 178
 179 /* idcache.c */
 180 char *getuser(uid_t uid);
 181 void free_getuser_cache();
 182 char *getgroup (gid_t gid);
 183 void free_getgroup_cache();
 184
 185 /* python.c */
 186 typedef int (EVENT_HANDLER)(JCR *jcr, const char *event);
 187 void init_python_interpreter(const char *progname, const char *scripts,
 188                              const char *module);
 189 void term_python_interpreter();
 190 //extern EVENT_HANDLER *generate_daemon_event;
 191 int generate_daemon_event(JCR *jcr, const char *event);
 192 void lock_python();
 193 void unlock_python();
 194
 195 /* signal.c */
 196 void             init_signals             (void terminate(int sig));
 197 void             init_stack_dump          (void);
 198
 199 /* scan.c */
 200 void             strip_leading_space     (char *str);
 201 void             strip_trailing_junk     (char *str);
 202 void             strip_trailing_newline  (char *str);
 203 void             strip_trailing_slashes  (char *dir);
 204 bool             skip_spaces             (char **msg);
 205 bool             skip_nonspaces          (char **msg);
 206 int              fstrsch                 (const char *a, const char *b);
 207 char            *next_arg(char **s);
 208 int              parse_args(POOLMEM *cmd, POOLMEM **args, int *argc,
 209                         char **argk, char **argv, int max_args);
 210 void            split_path_and_filename(const char *fname, POOLMEM **path,
 211                         int *pnl, POOLMEM **file, int *fnl);
 212 int             bsscanf(const char *buf, const char *fmt, ...);
 213
 214
 215 /* tls.c */
 216 int              init_tls                (void);
 217 int              cleanup_tls             (void);
 218
 219 TLS_CONTEXT      *new_tls_context        (const char *ca_certfile,
 220                                           const char *ca_certdir,
 221                                           const char *certfile,
 222                                           const char *keyfile,
 223                                           TLS_PEM_PASSWD_CB *pem_callback,
 224                                           const void *pem_userdata,
 225                                           const char *dhfile,
 226                                           bool verify_peer);
 227 void             free_tls_context        (TLS_CONTEXT *ctx);
 228 #ifdef HAVE_TLS
 229 bool             tls_postconnect_verify_host  (TLS_CONNECTION *tls,
 230                                                const char *host);
 231 bool             tls_postconnect_verify_cn    (TLS_CONNECTION *tls,
 232                                                alist *verify_list);
 233 TLS_CONNECTION   *new_tls_connection     (TLS_CONTEXT *ctx, int fd);
 234 void             free_tls_connection     (TLS_CONNECTION *tls);
 235 bool             tls_bsock_connect       (BSOCK *bsock);
 236 bool             tls_bsock_accept        (BSOCK *bsock);
 237 void             tls_bsock_shutdown      (BSOCK *bsock);
 238 int              tls_bsock_writen        (BSOCK *bsock, char *ptr, int32_t nbytes);
 239 int              tls_bsock_readn         (BSOCK *bsock, char *ptr, int32_t nbytes);
 240 #endif /* HAVE_TLS */
 241
 242
 243 /* util.c */
 244 int              is_buf_zero             (char *buf, int len);
 245 void             lcase                   (char *str);
 246 void             bash_spaces             (char *str);
 247 void             bash_spaces             (POOL_MEM &pm);
 248 void             unbash_spaces           (char *str);
 249 void             unbash_spaces           (POOL_MEM &pm);
 250 char *           encode_time             (time_t time, char *buf);
 251 char *           encode_mode             (mode_t mode, char *buf);
 252 int              do_shell_expansion      (char *name, int name_len);
 253 void             jobstatus_to_ascii      (int JobStatus, char *msg, int maxlen);
 254 int              run_program             (char *prog, int wait, POOLMEM *results);
 255 int              run_program_full_output (char *prog, int wait, POOLMEM *results);
 256 const char *     job_type_to_str         (int type);
 257 const char *     job_status_to_str       (int stat);
 258 const char *     job_level_to_str        (int level);
 259 void             make_session_key        (char *key, char *seed, int mode);
 260 POOLMEM         *edit_job_codes(JCR *jcr, char *omsg, char *imsg, const char *to);
 261 void             set_working_directory(char *wd);
 262
 263
 264 /* watchdog.c */
 265 int start_watchdog(void);
 266 int stop_watchdog(void);
 267 watchdog_t *new_watchdog(void);
 268 bool register_watchdog(watchdog_t *wd);
 269 bool unregister_watchdog(watchdog_t *wd);
 270
 271 /* timers.c */
 272 btimer_t *start_child_timer(pid_t pid, uint32_t wait);
 273 void stop_child_timer(btimer_t *wid);
 274 btimer_t *start_thread_timer(pthread_t tid, uint32_t wait);
 275 void stop_thread_timer(btimer_t *wid);
 276 btimer_t *start_bsock_timer(BSOCK *bs, uint32_t wait);
 277 void stop_bsock_timer(btimer_t *wid);