In SD allow Device to have Multiple MediaTypes
After 1.33:
+Ideas from Jerry Scharf:
+ First let's point out some big pluses that bacula has for this
+ it's open source
+ more importantly it's active. Thank you so much for that
+ even more important, it's not flaky
+ it has an open access catalog, opening many possibilities
+ it's pushing toward heterogeneous systems capability
+ simple things:
+ I don't remember an include file directive for config files
+ (not filesets, actual config directives)
+ can you check the configs without starting the daemon?
+ some warnings about possible common mistakes
+ big things:
+ doing the testing and blessing of concurrent backup writes
+ this is absolutely necessary in the enterprise
+ easy user recovery GUI with full access checking
+ Macintosh file client
+ macs are an interesting niche, but I fear a server is a rathole
+ working bare iron recovery for windows
+ much better handling on running config changes
+ thinking through the logic of what happens to jobs in progress
+ the option for inc/diff backups not reset on fileset revision
+ a) use both change and inode update time against base time
+ b) do the full catalog check (expensive but accurate)
+ sizing guide (how much system is needed to back up N systems/files)
+ consultants on using bacula in building a disaster recovery system
+ an integration guide
+ or how to get at fancy things that one could do with bacula
+ logwatch code for bacula logs (or similar)
+ linux distro inclusion of bacula (brings good and bad, but necessary)
+ win2k/XP server capability (icky but you asked)
+ support for Oracle database ??
+===
- Look at adding SQL server and Exchange support for Windows.
- Restore: Enter Filename: 'C:/Documents and Settings/Comercial/My
Documents/MOP/formulário de registro BELAS ARTES.doc' causes Bacula to
if (ndir > 1) {
- UA_sock = init_bsock(NULL, 0, "", "", 0);
+ struct sockaddr_in client_addr;
+ memset(&client_addr, 0, sizeof(client_addr));
+ UA_sock = init_bsock(NULL, 0, "", "", 0, &client_addr);
try_again:
sendit(_("Available Directors:\n"));
LockRes();
/*********************************************************************
*
*/
-int authenticate_user_agent(BSOCK *ua)
+int authenticate_user_agent(UAContext *uac)
{
char name[MAX_NAME_LENGTH];
int ssl_need = BNET_SSL_NONE;
bool ok;
+ BSOCK *ua = uac->UA_sock;
if (ua->msglen < 16 || ua->msglen >= MAX_NAME_LENGTH + 15) {
Emsg2(M_ERROR, 0, _("UA Hello from %s is invalid. Len=%d\n"), ua->who,
ua->msg);
return 0;
}
+// Dmsg2(000, "Console=%s addr=%s\n", name, inet_ntoa(ua->client_addr.sin_addr));
name[MAXSTRING-1] = 0; /* terminate name */
if (strcmp(name, "*UserAgent*") == 0) { /* default console */
ok = cram_md5_auth(ua, director->password, ssl_need) &&
if (cons) {
ok = cram_md5_auth(ua, cons->password, ssl_need) &&
cram_md5_get_auth(ua, cons->password, ssl_need);
+ if (ok) {
+ uac->cons = cons; /* save console resource pointer */
+ }
} else {
ok = false;
}
/* authenticate.c */
extern int authenticate_storage_daemon(JCR *jcr);
extern int authenticate_file_daemon(JCR *jcr);
-extern int authenticate_user_agent(BSOCK *ua);
+extern int authenticate_user_agent(UAContext *ua);
/* autoprune.c */
extern int do_autoprune(JCR *jcr);
/* fd_cmds.c */
extern int connect_to_file_daemon(JCR *jcr, int retry_interval,
- int max_retry_time, int verbose);
+ int max_retry_time, int verbose);
extern int send_include_list(JCR *jcr);
extern int send_exclude_list(JCR *jcr);
extern int send_bootstrap_file(JCR *jcr);
extern int get_attributes_and_put_in_catalog(JCR *jcr);
extern int get_attributes_and_compare_to_catalog(JCR *jcr, JobId_t JobId);
extern int put_file_into_catalog(JCR *jcr, long file_index, char *fname,
- char *link, char *attr, int stream);
+ char *link, char *attr, int stream);
extern void get_level_since_time(JCR *jcr, char *since, int since_len);
extern int send_run_before_and_after_commands(JCR *jcr);
/* msgchan.c */
extern int connect_to_storage_daemon(JCR *jcr, int retry_interval,
- int max_retry_time, int verbose);
+ int max_retry_time, int verbose);
extern int start_storage_daemon_job(JCR *jcr);
extern int start_storage_daemon_message_thread(JCR *jcr);
extern int bget_dirmsg(BSOCK *bs);
void free_ua_context(UAContext *ua);
/* ua_select.c */
-STORE *select_storage_resource(UAContext *ua);
-JOB *select_job_resource(UAContext *ua);
-JOB *select_restore_job_resource(UAContext *ua);
-CLIENT *select_client_resource(UAContext *ua);
+STORE *select_storage_resource(UAContext *ua);
+JOB *select_job_resource(UAContext *ua);
+JOB *select_restore_job_resource(UAContext *ua);
+CLIENT *select_client_resource(UAContext *ua);
FILESET *select_fileset_resource(UAContext *ua);
-int select_pool_and_media_dbr(UAContext *ua, POOL_DBR *pr, MEDIA_DBR *mr);
-int select_media_dbr(UAContext *ua, MEDIA_DBR *mr);
-int select_pool_dbr(UAContext *ua, POOL_DBR *pr);
-int select_client_dbr(UAContext *ua, CLIENT_DBR *cr);
-
-void start_prompt(UAContext *ua, char *msg);
-void add_prompt(UAContext *ua, char *prompt);
-int do_prompt(UAContext *ua, char *automsg, char *msg, char *prompt, int max_prompt);
-CAT *get_catalog_resource(UAContext *ua);
+int select_pool_and_media_dbr(UAContext *ua, POOL_DBR *pr, MEDIA_DBR *mr);
+int select_media_dbr(UAContext *ua, MEDIA_DBR *mr);
+int select_pool_dbr(UAContext *ua, POOL_DBR *pr);
+int select_client_dbr(UAContext *ua, CLIENT_DBR *cr);
+
+void start_prompt(UAContext *ua, char *msg);
+void add_prompt(UAContext *ua, char *prompt);
+int do_prompt(UAContext *ua, char *automsg, char *msg, char *prompt, int max_prompt);
+CAT *get_catalog_resource(UAContext *ua);
STORE *get_storage_resource(UAContext *ua, int use_default);
-int get_media_type(UAContext *ua, char *MediaType, int max_media);
-int get_pool_dbr(UAContext *ua, POOL_DBR *pr);
-int get_client_dbr(UAContext *ua, CLIENT_DBR *cr);
+int get_media_type(UAContext *ua, char *MediaType, int max_media);
+int get_pool_dbr(UAContext *ua, POOL_DBR *pr);
+int get_client_dbr(UAContext *ua, CLIENT_DBR *cr);
POOL *get_pool_resource(UAContext *ua);
POOL *select_pool_resource(UAContext *ua);
CLIENT *get_client_resource(UAContext *ua);
-int get_job_dbr(UAContext *ua, JOB_DBR *jr);
+int get_job_dbr(UAContext *ua, JOB_DBR *jr);
int find_arg_keyword(UAContext *ua, char **list);
int find_arg(UAContext *ua, char *keyword);
JCR *jcr;
B_DB *db;
CAT *catalog;
+ CONRES *cons; /* console resource */
POOLMEM *cmd; /* return command/name buffer */
POOLMEM *args; /* command line arguments */
char *argk[MAX_CMD_ARGS]; /* argument keywords */
job->hdr.name, rx.ClientName, rx.store?rx.store->hdr.name:"",
working_directory);
}
- if (find_arg(ua, _("run")) >= 0 || find_arg(ua, _("yes"))) {
+ if (find_arg(ua, _("yes")) > 0) {
pm_strcat(&ua->cmd, " yes"); /* pass it on to the run command */
}
Dmsg1(400, "Submitting: %s\n", ua->cmd);
char *when, *verify_job_name;
int Priority = 0;
int i, j, opt;
- bool found;
+ bool kw_ok;
JOB *job = NULL;
JOB *verify_job = NULL;
STORE *store = NULL;
N_("when"), /* 12 */
N_("priority"), /* 13 */
N_("yes"), /* 14 -- if you change this change YES_POS too */
- N_("verifyjob"), /* 16 */
+ N_("verifyjob"), /* 15 */
+ N_("files"), /* 16 number of files to restore */
NULL};
#define YES_POS 14
verify_job_name = NULL;
for (i=1; i<ua->argc; i++) {
- found = false;
Dmsg2(200, "Doing arg %d = %s\n", i, ua->argk[i]);
- for (j=0; !found && kw[j]; j++) {
+ kw_ok = false;
+ /* Keep looking until we find a good keyword */
+ for (j=0; !kw_ok && kw[j]; j++) {
if (strcasecmp(ua->argk[i], _(kw[j])) == 0) {
/* Note, yes and run have no value, so do not err */
if (!ua->argv[i] && j != YES_POS /*yes*/) {
return 1;
}
job_name = ua->argv[i];
- found = true;
+ kw_ok = true;
break;
case 1: /* JobId */
if (jid) {
return 1;
}
jid = ua->argv[i];
- found = true;
+ kw_ok = true;
break;
case 2: /* client */
case 3: /* fd */
return 1;
}
client_name = ua->argv[i];
- found = true;
+ kw_ok = true;
break;
case 4: /* fileset */
if (fileset_name) {
return 1;
}
fileset_name = ua->argv[i];
- found = true;
+ kw_ok = true;
break;
case 5: /* level */
if (level_name) {
return 1;
}
level_name = ua->argv[i];
- found = true;
+ kw_ok = true;
break;
case 6: /* storage */
case 7: /* sd */
return 1;
}
store_name = ua->argv[i];
- found = true;
+ kw_ok = true;
break;
case 8: /* pool */
if (pool_name) {
return 1;
}
pool_name = ua->argv[i];
- found = true;
+ kw_ok = true;
break;
case 9: /* where */
if (where) {
return 1;
}
where = ua->argv[i];
- found = true;
+ kw_ok = true;
break;
case 10: /* bootstrap */
if (bootstrap) {
return 1;
}
bootstrap = ua->argv[i];
- found = true;
+ kw_ok = true;
break;
case 11: /* replace */
if (replace) {
return 1;
}
replace = ua->argv[i];
- found = true;
+ kw_ok = true;
break;
case 12: /* When */
if (when) {
return 1;
}
when = ua->argv[i];
- found = true;
+ kw_ok = true;
break;
case 13: /* Priority */
if (Priority) {
bsendmsg(ua, _("Priority must be positive nonzero setting it to 10.\n"));
Priority = 10;
}
+ kw_ok = true;
break;
case 14: /* yes */
- found = true;
+ kw_ok = true;
break;
case 15: /* Verify Job */
if (verify_job_name) {
return 1;
}
verify_job_name = ua->argv[i];
- found = true;
+ kw_ok = true;
+ break;
+ case 16: /* files -- ignore for now */
+ kw_ok = true;
break;
default:
}
} /* end strcase compare */
} /* end keyword loop */
- if (!found) {
+ /*
+ * End of keyword for loop -- if not found, we got a bogus keyword
+ */
+ if (!kw_ok) {
Dmsg1(200, "%s not found\n", ua->argk[i]);
/*
* Special case for Job Name, it can be the first
}
if (level_name) {
/* Look up level name and pull code */
- found = 0;
+ bool found = false;
for (i=0; joblevels[i].level_name; i++) {
if (strcasecmp(level_name, _(joblevels[i].level_name)) == 0) {
jcr->JobLevel = joblevels[i].level;
- found = 1;
+ found = true;
break;
}
}
ua->UA_sock = UA_sock;
bnet_recv(ua->UA_sock); /* Get first message */
- if (!authenticate_user_agent(ua->UA_sock)) {
+ if (!authenticate_user_agent(ua)) {
goto getout;
}
if (inetd_request) {
/* Socket is on fd 0 */
- BSOCK *bs = init_bsock(NULL, 0, "client", "unknown client", me->FDport);
+ struct sockaddr_in client_addr;
+ memset(&client_addr, 0, sizeof(client_addr));
+ BSOCK *bs = init_bsock(NULL, 0, "client", "unknown client", me->FDport,
+ &client_addr);
handle_client_request((void *)bs);
} else {
/* Become server, and handle requests */
close(sockfd);
return NULL;
}
- return init_bsock(jcr, sockfd, name, host, port);
+ return init_bsock(jcr, sockfd, name, host, port, &tcp_serv_addr);
}
/*
* This probably should be done in net_open
*/
BSOCK *
-init_bsock(JCR *jcr, int sockfd, char *who, char *host, int port)
+init_bsock(JCR *jcr, int sockfd, char *who, char *host, int port,
+ struct sockaddr_in *client_addr)
{
BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
memset(bsock, 0, sizeof(BSOCK));
bsock->who = bstrdup(who);
bsock->host = bstrdup(host);
bsock->port = port;
+ memcpy(&bsock->client_addr, client_addr, sizeof(bsock->client_addr));
/*
* ****FIXME**** reduce this to a few hours once
* heartbeats are implemented
caller = "unknown client";
}
- BSOCK *bs = init_bsock(NULL, newsockfd, "client", caller, port);
+ BSOCK *bs = init_bsock(NULL, newsockfd, "client", caller, port, &cli_addr);
if (bs == NULL) {
Jmsg0(NULL, M_ABORT, 0, _("Could not create client BSOCK.\n"));
}
bmicrosleep(5, 0);
}
listen(sockfd, 1); /* tell system we are ready */
- return init_bsock(NULL, sockfd, _("Server socket"), _("client"), port);
+ return init_bsock(NULL, sockfd, _("Server socket"), _("client"), port, &serv_addr);
}
/*
strcpy(buf, who);
strcat(buf, ": ");
strcat(buf, caller);
- bs = init_bsock(NULL, newsockfd, "client", buf, bsock->port);
+ bs = init_bsock(NULL, newsockfd, "client", buf, bsock->port, &cli_addr);
free(buf);
return bs; /* return new BSOCK */
}
uint32_t out_msg_no; /* output message number */
int fd; /* socket file descriptor */
int32_t msglen; /* message length */
- int port; /* desired port */
- volatile int errors; /* set if errors on socket */
- volatile int suppress_error_msgs; /* set to suppress error messages */
int b_errno; /* bsock errno */
+ int port; /* desired port */
+ volatile bool errors: 1; /* set if errors on socket */
+ volatile bool suppress_error_msgs: 1; /* set to suppress error messages */
+ volatile bool timed_out: 1; /* timed out in read/write */
+ volatile bool terminated: 1; /* set when BNET_TERMINATE arrives */
+ bool duped: 1; /* set if duped BSOCK */
+ bool spool: 1; /* set for spooling */
volatile time_t timer_start; /* time started read/write */
- volatile int timed_out; /* timed out in read/write */
- volatile int timeout; /* time out after this value */
- volatile int terminated; /* set when BNET_TERMINATE arrives */
- int duped; /* set if duped BSOCK */
+ volatile time_t timeout; /* timeout BSOCK after this interval */
POOLMEM *msg; /* message pool buffer */
char *who; /* Name of daemon to which we are talking */
char *host; /* Host name/IP */
POOLMEM *errmsg; /* edited error message (to be implemented) */
RES *res; /* Resource to which we are connected */
BSOCK *next; /* next BSOCK if duped */
- int spool; /* set for spooling */
FILE *spool_fd; /* spooling file */
JCR *jcr; /* jcr or NULL for error msgs */
+ struct sockaddr_in client_addr; /* client's IP address */
};
/* Signal definitions for use in bnet_sig() */
struct JCR;
/* attr.c */
-ATTR *new_attr();
-void free_attr(ATTR *attr);
-int unpack_attributes_record(JCR *jcr, int32_t stream, char *rec, ATTR *attr);
-void build_attr_output_fnames(JCR *jcr, ATTR *attr);
-void print_ls_output(JCR *jcr, ATTR *attr);
+ATTR *new_attr();
+void free_attr(ATTR *attr);
+int unpack_attributes_record(JCR *jcr, int32_t stream, char *rec, ATTR *attr);
+void build_attr_output_fnames(JCR *jcr, ATTR *attr);
+void print_ls_output(JCR *jcr, ATTR *attr);
/* base64.c */
-void base64_init (void);
-int to_base64 (intmax_t value, char *where);
-int from_base64 (intmax_t *value, char *where);
-int bin_to_base64 (char *buf, char *bin, int len);
+void base64_init (void);
+int to_base64 (intmax_t value, char *where);
+int from_base64 (intmax_t *value, char *where);
+int bin_to_base64 (char *buf, char *bin, int len);
/* bsys.c */
-char *bstrncpy (char *dest, const char *src, int maxlen);
-char *bstrncat (char *dest, const char *src, int maxlen);
-void *b_malloc (char *file, int line, size_t size);
+char *bstrncpy (char *dest, const char *src, int maxlen);
+char *bstrncat (char *dest, const char *src, int maxlen);
+void *b_malloc (char *file, int line, size_t size);
#ifndef DEBUG
-void *bmalloc (size_t size);
+void *bmalloc (size_t size);
#endif
-void *brealloc (void *buf, size_t size);
-void *bcalloc (size_t size1, size_t size2);
-int bsnprintf (char *str, int32_t size, const char *format, ...);
-int bvsnprintf (char *str, int32_t size, const char *format, va_list ap);
-int pool_sprintf (char *pool_buf, char *fmt, ...);
-void create_pid_file (char *dir, char *progname, int port);
-int delete_pid_file (char *dir, char *progname, int port);
-void drop (char *uid, char *gid);
-int bmicrosleep (time_t sec, long usec);
-char *bfgets (char *s, int size, FILE *fd);
-void make_unique_filename (POOLMEM **name, int Id, char *what);
+void *brealloc (void *buf, size_t size);
+void *bcalloc (size_t size1, size_t size2);
+int bsnprintf (char *str, int32_t size, const char *format, ...);
+int bvsnprintf (char *str, int32_t size, const char *format, va_list ap);
+int pool_sprintf (char *pool_buf, char *fmt, ...);
+void create_pid_file (char *dir, char *progname, int port);
+int delete_pid_file (char *dir, char *progname, int port);
+void drop (char *uid, char *gid);
+int bmicrosleep (time_t sec, long usec);
+char *bfgets (char *s, int size, FILE *fd);
+void make_unique_filename (POOLMEM **name, int Id, char *what);
#ifndef HAVE_STRTOLL
-long long int strtoll (const char *ptr, char **endptr, int base);
+long long int strtoll (const char *ptr, char **endptr, int base);
#endif
/* bnet.c */
-int32_t bnet_recv (BSOCK *bsock);
-int bnet_send (BSOCK *bsock);
-int bnet_fsend (BSOCK *bs, char *fmt, ...);
-int bnet_set_buffer_size (BSOCK *bs, uint32_t size, int rw);
-int bnet_sig (BSOCK *bs, int sig);
-int bnet_ssl_server (BSOCK *bsock, char *password, int ssl_need, int ssl_has);
-int bnet_ssl_client (BSOCK *bsock, char *password, int ssl_need);
-BSOCK * bnet_connect (JCR *jcr, int retry_interval,
- int max_retry_time, char *name, char *host, char *service,
- int port, int verbose);
-void bnet_close (BSOCK *bsock);
-BSOCK * init_bsock (JCR *jcr, int sockfd, char *who, char *ip, int port);
-BSOCK * dup_bsock (BSOCK *bsock);
-void term_bsock (BSOCK *bsock);
-char * bnet_strerror (BSOCK *bsock);
-char * bnet_sig_to_ascii (BSOCK *bsock);
-int bnet_wait_data (BSOCK *bsock, int sec);
-int bnet_wait_data_intr (BSOCK *bsock, int sec);
-int bnet_despool (BSOCK *bsock);
-int is_bnet_stop (BSOCK *bsock);
-int is_bnet_error (BSOCK *bsock);
-void bnet_suppress_error_messages(BSOCK *bsock, int flag);
+int32_t bnet_recv (BSOCK *bsock);
+int bnet_send (BSOCK *bsock);
+int bnet_fsend (BSOCK *bs, char *fmt, ...);
+int bnet_set_buffer_size (BSOCK *bs, uint32_t size, int rw);
+int bnet_sig (BSOCK *bs, int sig);
+int bnet_ssl_server (BSOCK *bsock, char *password, int ssl_need, int ssl_has);
+int bnet_ssl_client (BSOCK *bsock, char *password, int ssl_need);
+BSOCK * bnet_connect (JCR *jcr, int retry_interval,
+ int max_retry_time, char *name, char *host, char *service,
+ int port, int verbose);
+void bnet_close (BSOCK *bsock);
+BSOCK * init_bsock (JCR *jcr, int sockfd, char *who, char *ip,
+ int port, struct sockaddr_in *client_addr);
+BSOCK * dup_bsock (BSOCK *bsock);
+void term_bsock (BSOCK *bsock);
+char * bnet_strerror (BSOCK *bsock);
+char * bnet_sig_to_ascii (BSOCK *bsock);
+int bnet_wait_data (BSOCK *bsock, int sec);
+int bnet_wait_data_intr (BSOCK *bsock, int sec);
+int bnet_despool (BSOCK *bsock);
+int is_bnet_stop (BSOCK *bsock);
+int is_bnet_error (BSOCK *bsock);
+void bnet_suppress_error_messages(BSOCK *bsock, int flag);
/* bget_msg.c */
-int bget_msg(BSOCK *sock);
+int bget_msg(BSOCK *sock);
/* bpipe.c */
-BPIPE * open_bpipe(char *prog, int wait, char *mode);
-int close_wpipe(BPIPE *bpipe);
-int close_bpipe(BPIPE *bpipe);
+BPIPE * open_bpipe(char *prog, int wait, char *mode);
+int close_wpipe(BPIPE *bpipe);
+int close_bpipe(BPIPE *bpipe);
/* cram-md5.c */
int cram_md5_get_auth(BSOCK *bs, char *password, int ssl_need);
int cram_md5_auth(BSOCK *bs, char *password, int ssl_need);
void hmac_md5(uint8_t* text, int text_len, uint8_t* key,
- int key_len, uint8_t *hmac);
+ int key_len, uint8_t *hmac);
/* crc32.c */
uint32_t bcrc32(uint8_t *buf, int len);
/* daemon.c */
-void daemon_start ();
+void daemon_start ();
/* edit.c */
-uint64_t str_to_uint64(char *str);
-int64_t str_to_int64(char *str);
-char * edit_uint64_with_commas (uint64_t val, char *buf);
-char * add_commas (char *val, char *buf);
-char * edit_uint64 (uint64_t val, char *buf);
-int duration_to_utime (char *str, utime_t *value);
-int size_to_uint64(char *str, int str_len, uint64_t *rtn_value);
-char *edit_utime (utime_t val, char *buf);
-int is_a_number (const char *num);
-int is_an_integer (const char *n);
-bool is_name_valid (char *name, POOLMEM **msg);
+uint64_t str_to_uint64(char *str);
+int64_t str_to_int64(char *str);
+char * edit_uint64_with_commas (uint64_t val, char *buf);
+char * add_commas (char *val, char *buf);
+char * edit_uint64 (uint64_t val, char *buf);
+int duration_to_utime (char *str, utime_t *value);
+int size_to_uint64(char *str, int str_len, uint64_t *rtn_value);
+char *edit_utime (utime_t val, char *buf);
+int is_a_number (const char *num);
+int is_an_integer (const char *n);
+bool is_name_valid (char *name, POOLMEM **msg);
/* jcr.c (most definitions are in src/jcr.h) */
void init_last_jobs_list();
/* lex.c */
-LEX * lex_close_file (LEX *lf);
-LEX * lex_open_file (LEX *lf, char *fname, LEX_ERROR_HANDLER *scan_error);
-int lex_get_char (LEX *lf);
-void lex_unget_char (LEX *lf);
-char * lex_tok_to_str (int token);
-int lex_get_token (LEX *lf, int expect);
+LEX * lex_close_file (LEX *lf);
+LEX * lex_open_file (LEX *lf, char *fname, LEX_ERROR_HANDLER *scan_error);
+int lex_get_char (LEX *lf);
+void lex_unget_char (LEX *lf);
+char * lex_tok_to_str (int token);
+int lex_get_token (LEX *lf, int expect);
/* message.c */
-void my_name_is (int argc, char *argv[], char *name);
-void init_msg (JCR *jcr, MSGS *msg);
-void term_msg (void);
-void close_msg (JCR *jcr);
-void add_msg_dest (MSGS *msg, int dest, int type, char *where, char *dest_code);
-void rem_msg_dest (MSGS *msg, int dest, int type, char *where);
-void Jmsg (JCR *jcr, int type, int level, char *fmt, ...);
-void dispatch_message (JCR *jcr, int type, int level, char *buf);
-void init_console_msg (char *wd);
-void free_msgs_res (MSGS *msgs);
-int open_spool_file (JCR *jcr, BSOCK *bs);
-int close_spool_file (JCR *jcr, BSOCK *bs);
+void my_name_is (int argc, char *argv[], char *name);
+void init_msg (JCR *jcr, MSGS *msg);
+void term_msg (void);
+void close_msg (JCR *jcr);
+void add_msg_dest (MSGS *msg, int dest, int type, char *where, char *dest_code);
+void rem_msg_dest (MSGS *msg, int dest, int type, char *where);
+void Jmsg (JCR *jcr, int type, int level, char *fmt, ...);
+void dispatch_message (JCR *jcr, int type, int level, char *buf);
+void init_console_msg (char *wd);
+void free_msgs_res (MSGS *msgs);
+int open_spool_file (JCR *jcr, BSOCK *bs);
+int close_spool_file (JCR *jcr, BSOCK *bs);
/* bnet_server.c */
-void bnet_thread_server(char *bind_addr, int port, int max_clients, workq_t *client_wq,
- void *handle_client_request(void *bsock));
-void bnet_server (int port, void handle_client_request(BSOCK *bsock));
-int net_connect (int port);
-BSOCK * bnet_bind (int port);
-BSOCK * bnet_accept (BSOCK *bsock, char *who);
+void bnet_thread_server(char *bind_addr, int port, int max_clients, workq_t *client_wq,
+ void *handle_client_request(void *bsock));
+void bnet_server (int port, void handle_client_request(BSOCK *bsock));
+int net_connect (int port);
+BSOCK * bnet_bind (int port);
+BSOCK * bnet_accept (BSOCK *bsock, char *who);
/* idcache.c */
char *getuser(uid_t uid);
/* signal.c */
-void init_signals (void terminate(int sig));
-void init_stack_dump (void);
+void init_signals (void terminate(int sig));
+void init_stack_dump (void);
/* scan.c */
-void strip_trailing_junk (char *str);
-void strip_trailing_slashes (char *dir);
-bool skip_spaces (char **msg);
-bool skip_nonspaces (char **msg);
-int fstrsch (char *a, char *b);
-int parse_args(POOLMEM *cmd, POOLMEM **args, int *argc,
- char **argk, char **argv, int max_args);
-char *next_arg(char **s);
+void strip_trailing_junk (char *str);
+void strip_trailing_slashes (char *dir);
+bool skip_spaces (char **msg);
+bool skip_nonspaces (char **msg);
+int fstrsch (char *a, char *b);
+int parse_args(POOLMEM *cmd, POOLMEM **args, int *argc,
+ char **argk, char **argv, int max_args);
+char *next_arg(char **s);
/* util.c */
-int is_buf_zero (char *buf, int len);
-void lcase (char *str);
-void bash_spaces (char *str);
-void unbash_spaces (char *str);
-char * encode_time (time_t time, char *buf);
-char * encode_mode (mode_t mode, char *buf);
-int do_shell_expansion (char *name, int name_len);
-void jobstatus_to_ascii (int JobStatus, char *msg, int maxlen);
-int pm_strcat (POOLMEM **pm, char *str);
-int pm_strcpy (POOLMEM **pm, char *str);
-int run_program (char *prog, int wait, POOLMEM *results);
-char * job_type_to_str (int type);
-char * job_status_to_str (int stat);
-char * job_level_to_str (int level);
-void make_session_key (char *key, char *seed, int mode);
-POOLMEM *edit_job_codes(JCR *jcr, char *omsg, char *imsg, char *to);
-void set_working_directory(char *wd);
+int is_buf_zero (char *buf, int len);
+void lcase (char *str);
+void bash_spaces (char *str);
+void unbash_spaces (char *str);
+char * encode_time (time_t time, char *buf);
+char * encode_mode (mode_t mode, char *buf);
+int do_shell_expansion (char *name, int name_len);
+void jobstatus_to_ascii (int JobStatus, char *msg, int maxlen);
+int pm_strcat (POOLMEM **pm, char *str);
+int pm_strcpy (POOLMEM **pm, char *str);
+int run_program (char *prog, int wait, POOLMEM *results);
+char * job_type_to_str (int type);
+char * job_status_to_str (int stat);
+char * job_level_to_str (int level);
+void make_session_key (char *key, char *seed, int mode);
+POOLMEM *edit_job_codes(JCR *jcr, char *omsg, char *imsg, char *to);
+void set_working_directory(char *wd);
/* watchdog.c */
#include "jcr.h"
/* Exported globals */
-time_t watchdog_time; /* this has granularity of SLEEP_TIME */
+time_t watchdog_time = 0; /* this has granularity of SLEEP_TIME */
#define SLEEP_TIME 1 /* examine things every second */
recycle = strcmp(jcr->VolCatInfo.VolCatStatus, "Recycle") == 0;
if (recycle && dev->num_writers != 0) {
Jmsg(jcr, M_FATAL, 0, _("Cannot recycle volume \"%s\""
- " because it is in use by another job."));
+ " because it is in use by another job.\n"));
goto get_out;
}
}
if (!mount_next_write_volume(jcr, dev, block, release)) {
if (!job_canceled(jcr)) {
/* Reduce "noise" -- don't print if job canceled */
- Jmsg(jcr, M_FATAL, 0, _("Could not ready device %s for append.\n"),
+ Jmsg(jcr, M_FATAL, 0, _("Could not ready device \"%s\" for append.\n"),
dev_name(dev));
}
goto get_out;
if (status == 0) {
loaded = atoi(results);
} else {
- Jmsg(jcr, M_INFO, 0, _("3991 Bad autochanger \"load slot\" status=%d.\n"), status);
+ Jmsg(jcr, M_INFO, 0, _("3991 Bad autochanger \"loaded\" command, status=%d.\n"), status);
loaded = -1; /* force unload */
}
Dmsg1(400, "loaded=%s\n", results);
jcr->device->changer_command, "load");
status = run_program(changer, timeout, NULL);
if (status == 0) {
- Jmsg(jcr, M_INFO, 0, _("3304 Autochanger \"load slot %d\" status is OK.\n"),
+ Jmsg(jcr, M_INFO, 0, _("3304 Autochanger \"load slot %d\", status is OK.\n"),
slot);
} else {
- Jmsg(jcr, M_INFO, 0, _("3992 Bad autochanger \"load slot\" status=%d.\n"),
- status);
+ Jmsg(jcr, M_INFO, 0, _("3992 Bad autochanger \"load slot %d\", status=%d.\n"),
+ slot, status);
}
Dmsg2(400, "load slot %d status=%d\n", slot, status);
}
*/
if (!dev_cap(dev, CAP_STREAM)) {
if (!rewind_dev(dev)) {
- Jmsg2(jcr, M_WARNING, 0, _("Rewind error on device %s. ERR=%s\n"),
+ Jmsg2(jcr, M_WARNING, 0, _("Rewind error on device \"%s\". ERR=%s\n"),
dev_name(dev), strerror_dev(dev));
}
if (recycle) {
if (!truncate_dev(dev)) {
- Jmsg2(jcr, M_WARNING, 0, _("Truncate error on device %s. ERR=%s\n"),
+ Jmsg2(jcr, M_WARNING, 0, _("Truncate error on device \"%s\". ERR=%s\n"),
dev_name(dev), strerror_dev(dev));
}
}
/* Attempt write to check write permission */
if (!write_block_to_dev(jcr, dev, block)) {
- Jmsg2(jcr, M_ERROR, 0, _("Unable to write device %s. ERR=%s\n"),
+ Jmsg2(jcr, M_ERROR, 0, _("Unable to write device \"%s\". ERR=%s\n"),
dev_name(dev), strerror_dev(dev));
goto mount_next_vol;
}
bstrncpy(dev->VolCatInfo.VolCatStatus, "Append", sizeof(dev->VolCatInfo.VolCatStatus));
dir_update_volume_info(jcr, dev, 1); /* indicate doing relabel */
if (recycle) {
- Jmsg(jcr, M_INFO, 0, _("Recycled volume \"%s\" on device %s, all previous data lost.\n"),
+ Jmsg(jcr, M_INFO, 0, _("Recycled volume \"%s\" on device \"%s\", all previous data lost.\n"),
jcr->VolumeName, dev_name(dev));
} else {
- Jmsg(jcr, M_INFO, 0, _("Wrote label to prelabeled Volume \"%s\" on device %s\n"),
+ Jmsg(jcr, M_INFO, 0, _("Wrote label to prelabeled Volume \"%s\" on device \"%s\"\n"),
jcr->VolumeName, dev_name(dev));
}
/*
Jmsg(jcr, M_INFO, 0, _("Volume \"%s\" previously written, moving to end of data.\n"),
jcr->VolumeName);
if (!eod_dev(dev)) {
- Jmsg(jcr, M_ERROR, 0, _("Unable to position to end of data %s. ERR=%s\n"),
+ Jmsg(jcr, M_ERROR, 0, _("Unable to position to end of data on device \"%s\". ERR=%s\n"),
dev_name(dev), strerror_dev(dev));
mark_volume_in_error(jcr, dev);
goto mount_next_vol;
* that the database says we should be.
*/
if (dev->VolCatInfo.VolCatFiles == dev_file(dev)) {
- Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume at file=%d.\n"),
- dev_file(dev));
+ Jmsg(jcr, M_INFO, 0, _("Ready to append to end of Volume \"%s\" at file=%d.\n"),
+ jcr->VolumeName, dev_file(dev));
} else {
- Jmsg(jcr, M_ERROR, 0, _("I canot write on this volume because:\n\
+ Jmsg(jcr, M_ERROR, 0, _("I canot write on Volume \"%s\" because:\n\
The number of files mismatch! Volume=%u Catalog=%u\n"),
- dev_file(dev), dev->VolCatInfo.VolCatFiles);
+ jcr->VolumeName, dev_file(dev), dev->VolCatInfo.VolCatFiles);
mark_volume_in_error(jcr, dev);
goto mount_next_vol;
}
#undef VERSION
#define VERSION "1.33"
#define VSTRING "1"
-#define BDATE "14 Jan 2004"
-#define LSMDATE "14Jan04"
+#define BDATE "16 Jan 2004"
+#define LSMDATE "16Jan04"
/* Debug flags */
#undef DEBUG