static int restore_cmd(JCR *jcr);
static int storage_cmd(JCR *jcr);
static int session_cmd(JCR *jcr);
-static int response(JCR *jcr, BSOCK *sd, char *resp, char *cmd);
+static int response(JCR *jcr, BSOCK *sd, char *resp, const char *cmd);
static void filed_free_jcr(JCR *jcr);
static int open_sd_read_session(JCR *jcr);
static int send_bootstrap_file(JCR *jcr);
static int runbefore_cmd(JCR *jcr);
static int runafter_cmd(JCR *jcr);
-static int run_cmd(JCR *jcr, char *cmd, char *name);
+static int run_cmd(JCR *jcr, char *cmd, const char *name);
/* Exported functions */
}
set_jcr_job_status(cjcr, JS_Canceled);
free_jcr(cjcr);
- bnet_fsend(dir, "2001 Job %s marked to be canceled.\n", Job);
+ bnet_fsend(dir, _("2001 Job %s marked to be canceled.\n"), Job);
}
} else {
- bnet_fsend(dir, "2902 Error scanning cancel command.\n");
+ bnet_fsend(dir, _("2902 Error scanning cancel command.\n"));
}
bnet_sig(dir, BNET_EOD);
return 1;
return bnet_fsend(dir, OKRunAfter);
}
-static int run_cmd(JCR *jcr, char *cmd, char *name)
+static int run_cmd(JCR *jcr, char *cmd, const char *name)
{
POOLMEM *ecmd = get_pool_memory(PM_FNAME);
int status;
* Returns: 0 on failure
* 1 on success
*/
-int response(JCR *jcr, BSOCK *sd, char *resp, char *cmd)
+int response(JCR *jcr, BSOCK *sd, char *resp, const char *cmd)
{
if (sd->errors) {
return 0;
/* Forward referenced functions */
#ifdef HAVE_LIBZ
-static char *zlib_strerror(int stat);
+static const char *zlib_strerror(int stat);
#endif
#define RETRY 10 /* retry wait time */
/*
* Convert ZLIB error code into an ASCII message
*/
-static char *zlib_strerror(int stat)
+static const char *zlib_strerror(int stat)
{
if (stat >= 0) {
return "None";
extern time_t daemon_start_time;
/* Forward referenced functions */
-static void list_terminated_jobs(void sendit(char *msg, int len, void *sarg), void *arg);
-static void bsock_sendit(char *msg, int len, void *arg);
+static void list_terminated_jobs(void sendit(const char *msg, int len, void *sarg), void *arg);
+static void bsock_sendit(const char *msg, int len, void *arg);
static char *level_to_str(int level);
/*
* General status generator
*/
-static void do_status(void sendit(char *msg, int len, void *sarg), void *arg)
+static void do_status(void sendit(const char *msg, int len, void *sarg), void *arg)
{
int sec, bps;
char *msg, b1[32], b2[32], b3[32];
free_pool_memory(msg);
}
-static void list_terminated_jobs(void sendit(char *msg, int len, void *sarg), void *arg)
+static void list_terminated_jobs(void sendit(const char *msg, int len, void *sarg), void *arg)
{
char dt[MAX_TIME_LENGTH], b1[30], b2[30];
char level[10];
struct s_last_job *je;
- char *msg;
+ const char *msg;
if (last_job.NumJobs == 0) {
msg = _("No Terminated Jobs.\n");
/*
* Send to bsock (Director or Console)
*/
-static void bsock_sendit(char *msg, int len, void *arg)
+static void bsock_sendit(const char *msg, int len, void *arg)
{
BSOCK *user = (BSOCK *)arg;
/*
* Put message in Window List Box
*/
-static void win32_sendit(char *msg, int len, void *marg)
+static void win32_sendit(const char *msg, int len, void *marg)
{
struct s_win32_arg *arg = (struct s_win32_arg *)marg;
if (len > 0 && msg[len-1] == '\n') {
// when compiling with visual studio some strings are read-only
- // and cause access violations. So we creat a tmp copy.
+ // and cause access violations. So we creat a tmp copy.
char *_msg = (char *)alloca(len);
strncpy(_msg, msg, len-1);
_msg[len-1] = 0;
return 0;
}
-char *stream_to_ascii(int stream)
+const char *stream_to_ascii(int stream)
{
static char buf[20];
return "SHA1 signature";
default:
sprintf(buf, "%d", stream);
- return buf;
+ return (const char *)buf;
}
}
enum {
BF_CLOSED,
- BF_READ, /* BackupRead */
- BF_WRITE /* BackupWrite */
+ BF_READ, /* BackupRead */
+ BF_WRITE /* BackupWrite */
};
/* In bfile.c */
/* Basic low level I/O file packet */
struct BFILE {
- int use_backup_api; /* set if using BackupRead/Write */
- int mode; /* set if file is open */
- HANDLE fh; /* Win32 file handle */
- int fid; /* fd if doing Unix style */
- LPVOID lpContext; /* BackupRead/Write context */
- POOLMEM *errmsg; /* error message buffer */
- DWORD rw_bytes; /* Bytes read or written */
- DWORD lerror; /* Last error code */
-};
+ int use_backup_api; /* set if using BackupRead/Write */
+ int mode; /* set if file is open */
+ HANDLE fh; /* Win32 file handle */
+ int fid; /* fd if doing Unix style */
+ LPVOID lpContext; /* BackupRead/Write context */
+ POOLMEM *errmsg; /* error message buffer */
+ DWORD rw_bytes; /* Bytes read or written */
+ DWORD lerror; /* Last error code */
+};
HANDLE bget_handle(BFILE *bfd);
-#else /* Linux/Unix systems */
+#else /* Linux/Unix systems */
/* Basic low level I/O file packet */
struct BFILE {
- int fid; /* file id on Unix */
+ int fid; /* file id on Unix */
int berrno;
-};
+};
#endif
-void binit(BFILE *bfd);
-int is_bopen(BFILE *bfd);
-int set_win32_backup(BFILE *bfd);
-int set_portable_backup(BFILE *bfd);
-int have_win32_api();
-int is_portable_backup(BFILE *bfd);
-int is_stream_supported(int stream);
-int is_win32_stream(int stream);
+void binit(BFILE *bfd);
+int is_bopen(BFILE *bfd);
+int set_win32_backup(BFILE *bfd);
+int set_portable_backup(BFILE *bfd);
+int have_win32_api();
+int is_portable_backup(BFILE *bfd);
+int is_stream_supported(int stream);
+int is_win32_stream(int stream);
char *berror(BFILE *bfd);
-int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode);
-int bclose(BFILE *bfd);
+int bopen(BFILE *bfd, const char *fname, int flags, mode_t mode);
+int bclose(BFILE *bfd);
ssize_t bread(BFILE *bfd, void *buf, size_t count);
ssize_t bwrite(BFILE *bfd, void *buf, size_t count);
-off_t blseek(BFILE *bfd, off_t offset, int whence);
-char *stream_to_ascii(int stream);
+off_t blseek(BFILE *bfd, off_t offset, int whence);
+const char *stream_to_ascii(int stream);
#endif /* __BFILE_H */
extern void set_jcr_job_status(JCR *jcr, int JobStatus);
#ifdef DEBUG
-extern void b_free_jcr(char *file, int line, JCR *jcr);
+extern void b_free_jcr(const char *file, int line, JCR *jcr);
#define free_jcr(jcr) b_free_jcr(__FILE__, __LINE__, (jcr))
#else
extern void free_jcr(JCR *jcr);
pm_strcpy(&attr->ofname, attr->fname);
pm_strcpy(&attr->olname, attr->lname);
} else {
- char *fn;
+ const char *fn;
int wherelen = strlen(jcr->where);
pm_strcpy(&attr->ofname, jcr->where); /* copy prefix */
if (win32_client && attr->fname[1] == ':') {
/*
* Get human readable error for gethostbyname()
*/
-static char *gethost_strerror()
+static const char *gethost_strerror()
{
switch (h_errno) {
case NETDB_INTERNAL:
* ***FIXME*** implement service from /etc/services
*/
static BSOCK *
-bnet_open(JCR *jcr, char *name, char *host, char *service, int port, int *fatal)
+bnet_open(JCR *jcr, const char *name, char *host, char *service, int port, int *fatal)
{
int sockfd;
struct sockaddr_in tcp_serv_addr; /* socket information */
* Try to connect to host for max_retry_time at retry_time intervals.
*/
BSOCK *
-bnet_connect(JCR *jcr, int retry_interval, int max_retry_time, char *name,
+bnet_connect(JCR *jcr, int retry_interval, int max_retry_time, const char *name,
char *host, char *service, int port, int verbose)
{
int i;
* 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, const char *who, char *host, int port,
struct sockaddr_in *client_addr)
{
BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
P(mutex);
caller = inet_ntoa(cli_addr.sin_addr); /* NOT thread safe, use mutex */
if (caller == NULL) {
- caller = "unknown client";
+ caller = _("unknown client");
}
BSOCK *bs = init_bsock(NULL, newsockfd, "client", caller, port, &cli_addr);
* a bi-directional pipe so that the user can read from and
* write to the program.
*/
-BPIPE *open_bpipe(char *prog, int wait, char *mode)
+BPIPE *open_bpipe(char *prog, int wait, const char *mode)
{
char *bargv[MAX_ARGV];
int bargc, i;
/*
* Create a standard "Unix" pid file.
*/
-void create_pid_file(char *dir, char *progname, int port)
+void create_pid_file(char *dir, const char *progname, int port)
{
#if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
int pidfd, len;
/*
* Delete the pid file if we created it
*/
-int delete_pid_file(char *dir, char *progname, int port)
+int delete_pid_file(char *dir, const char *progname, int port)
{
#if !defined(HAVE_CYGWIN) && !defined(HAVE_WIN32)
POOLMEM *fname = get_pool_memory(PM_FNAME);
* to months. These "kludges" make it compatible with pre 1.31
* Baculas.
*/
- static char *mod[] = {"n", "seconds", "months", "minutes",
- "hours", "days", "weeks", "quarters", "years", NULL};
- static int32_t mult[] = {60, 1, 60*60*24*30, 60,
+ static const char *mod[] = {"n", "seconds", "months", "minutes",
+ "hours", "days", "weeks", "quarters", "years", NULL};
+ static const int32_t mult[] = {60, 1, 60*60*24*30, 60,
60*60, 60*60*24, 60*60*24*7, 60*60*24*91, 60*60*24*365};
char mod_str[20];
int mod_len;
* Global routine to free a jcr
*/
#ifdef DEBUG
-void b_free_jcr(char *file, int line, JCR *jcr)
+void b_free_jcr(const char *file, int line, JCR *jcr)
{
Dmsg3(200, "Enter free_jcr 0x%x from %s:%d\n", jcr, file, line);
/*
* Timeout signal comes here
*/
-void timeout_handler(int sig)
+static void timeout_handler(int sig)
{
return; /* thus interrupting the function */
}
/*
* Format a scanner error message
*/
-static void s_err(char *file, int line, LEX *lc, char *msg, ...)
+static void s_err(const char *file, int line, LEX *lc, const char *msg, ...)
{
va_list arg_ptr;
char buf[MAXSTRING];
}
#ifdef DEBUG
-static char *lex_state_to_str(int state)
+static const char *lex_state_to_str(int state)
{
switch (state) {
case lex_none: return "none";
* Convert a lex token to a string
* used for debug/error printing.
*/
-char *lex_tok_to_str(int token)
+const char *lex_tok_to_str(int token)
{
switch(token) {
case L_EOF: return "L_EOF";
{
int64_t val = 0;
if (!is_a_number(str)) {
- scan_err1(lf, "expected a positive integer number, got: %s", str);
+ scan_err1(lf, _("expected a positive integer number, got: %s"), str);
/* NOT REACHED */
} else {
errno = 0;
val = str_to_int64(str);
if (errno != 0 || val < 0) {
- scan_err1(lf, "expected a postive integer number, got: %s", str);
+ scan_err1(lf, _("expected a postive integer number, got: %s"), str);
/* NOT REACHED */
}
}
} else {
char *p = strchr(lf->str, '-');
if (!p) {
- scan_err2(lf, "expected an integer or a range, got %s: %s",
+ scan_err2(lf, _("expected an integer or a range, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
break;
case T_INT32:
if (token != T_NUMBER || !is_a_number(lf->str)) {
- scan_err2(lf, "expected an integer number, got %s: %s",
+ scan_err2(lf, _("expected an integer number, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
break;
errno = 0;
lf->int32_val = (int32_t)str_to_int64(lf->str);
if (errno != 0) {
- scan_err2(lf, "expected an integer number, got %s: %s",
+ scan_err2(lf, _("expected an integer number, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
} else {
case T_INT64:
Dmsg2(900, "int64=:%s: %f\n", lf->str, strtod(lf->str, NULL));
if (token != T_NUMBER || !is_a_number(lf->str)) {
- scan_err2(lf, "expected an integer number, got %s: %s",
+ scan_err2(lf, _("expected an integer number, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
break;
errno = 0;
lf->int64_val = str_to_int64(lf->str);
if (errno != 0) {
- scan_err2(lf, "expected an integer number, got %s: %s",
+ scan_err2(lf, _("expected an integer number, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
} else {
case T_NAME:
if (token != T_IDENTIFIER && token != T_UNQUOTED_STRING && token != T_QUOTED_STRING) {
- scan_err2(lf, "expected a name, got %s: %s",
+ scan_err2(lf, _("expected a name, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
} else if (lf->str_len > MAX_RES_NAME_LENGTH) {
- scan_err3(lf, "name %s length %d too long, max is %d\n", lf->str,
+ scan_err3(lf, _("name %s length %d too long, max is %d\n"), lf->str,
lf->str_len, MAX_RES_NAME_LENGTH);
token = T_ERROR;
}
case T_STRING:
if (token != T_IDENTIFIER && token != T_UNQUOTED_STRING && token != T_QUOTED_STRING) {
- scan_err2(lf, "expected a string, got %s: %s",
+ scan_err2(lf, _("expected a string, got %s: %s"),
lex_tok_to_str(token), lf->str);
token = T_ERROR;
} else {
#define _LEX_H
/* Lex get_char() return values */
-#define L_EOF (-1)
-#define L_EOL (-2)
+#define L_EOF (-1)
+#define L_EOL (-2)
/* Internal tokens */
-#define T_NONE 100
+#define T_NONE 100
/* Tokens returned by get_token() */
-#define T_EOF 101
-#define T_NUMBER 102
-#define T_IPADDR 103
-#define T_IDENTIFIER 104
-#define T_UNQUOTED_STRING 105
-#define T_QUOTED_STRING 106
-#define T_BOB 108 /* begin block */
-#define T_EOB 109 /* end of block */
-#define T_EQUALS 110
-#define T_COMMA 111
-#define T_EOL 112
-#define T_SEMI 113
-#define T_ERROR 200
+#define T_EOF 101
+#define T_NUMBER 102
+#define T_IPADDR 103
+#define T_IDENTIFIER 104
+#define T_UNQUOTED_STRING 105
+#define T_QUOTED_STRING 106
+#define T_BOB 108 /* begin block */
+#define T_EOB 109 /* end of block */
+#define T_EQUALS 110
+#define T_COMMA 111
+#define T_EOL 112
+#define T_SEMI 113
+#define T_ERROR 200
/*
* The following will be returned only if
* the appropriate expect flag has been set
*/
-#define T_PINT32 114 /* positive integer */
-#define T_PINT32_RANGE 115 /* positive integer range */
-#define T_INT32 116 /* integer */
-#define T_INT64 117 /* 64 bit integer */
-#define T_NAME 118 /* name max 128 chars */
-#define T_STRING 119 /* string */
+#define T_PINT32 114 /* positive integer */
+#define T_PINT32_RANGE 115 /* positive integer range */
+#define T_INT32 116 /* integer */
+#define T_INT64 117 /* 64 bit integer */
+#define T_NAME 118 /* name max 128 chars */
+#define T_STRING 119 /* string */
-#define T_ALL 0 /* no expectations */
+#define T_ALL 0 /* no expectations */
/* Lexical state */
enum lex_state {
};
/* Lex scan options */
-#define LOPT_NO_IDENT 0x1 /* No Identifiers -- use string */
+#define LOPT_NO_IDENT 0x1 /* No Identifiers -- use string */
/* Lexical context */
typedef struct s_lex_context {
- struct s_lex_context *next; /* pointer to next lexical context */
- int options; /* scan options */
- char *fname; /* filename */
- FILE *fd; /* file descriptor */
- char line[MAXSTRING]; /* input line */
- char str[MAXSTRING]; /* string being scanned */
- int str_len; /* length of string */
- int line_no; /* file line number */
- int col_no; /* char position on line */
- int begin_line_no; /* line no of beginning of string */
- enum lex_state state; /* lex_state variable */
- int ch; /* last char/L_VAL returned by get_char */
+ struct s_lex_context *next; /* pointer to next lexical context */
+ int options; /* scan options */
+ char *fname; /* filename */
+ FILE *fd; /* file descriptor */
+ char line[MAXSTRING]; /* input line */
+ char str[MAXSTRING]; /* string being scanned */
+ int str_len; /* length of string */
+ int line_no; /* file line number */
+ int col_no; /* char position on line */
+ int begin_line_no; /* line no of beginning of string */
+ enum lex_state state; /* lex_state variable */
+ int ch; /* last char/L_VAL returned by get_char */
int token;
uint32_t pint32_val;
uint32_t pint32_val2;
int32_t int32_val;
int64_t int64_val;
- void (*scan_error)(char *file, int line, struct s_lex_context *lc, char *msg, ...);
- void *caller_ctx; /* caller private data */
+ void (*scan_error)(const char *file, int line, struct s_lex_context *lc, const char *msg, ...);
+ void *caller_ctx; /* caller private data */
} LEX;
-typedef void (LEX_ERROR_HANDLER)(char *file, int line, LEX *lc, char *msg, ...);
+typedef void (LEX_ERROR_HANDLER)(const char *file, int line, LEX *lc, const char *msg, ...);
/* Lexical scanning errors in parsing conf files */
#define scan_err0(lc, msg) lc->scan_error(__FILE__, __LINE__, lc, msg)
int verbose = 0; /* increase User messages */
int debug_level = 0; /* debug level */
time_t daemon_start_time = 0; /* Daemon start time */
-char *version = VERSION " (" BDATE ")";
+const char *version = VERSION " (" BDATE ")";
char my_name[30]; /* daemon name is stored here */
char *exepath = (char *)NULL;
char *exename = (char *)NULL;
va_list arg_ptr;
int len;
MSGS *msgs;
- char *job;
+ const char *job;
Dmsg1(800, "Enter Jmsg type=%d\n", type);
M_ERROR_TERM, /* Error termination request (no dump) */
M_TERM, /* Terminating daemon normally */
M_RESTORED, /* ls -l of restored files */
- M_SECURITY, /* security violation */
+ M_SECURITY /* security violation */
};
#define M_MAX M_SECURITY /* keep this updated ! */
extern "C" CURES res_all;
extern "C" int res_all_size;
#else
-extern CURES res_all;
+extern CURES res_all;
extern int res_all_size;
#endif
};
struct s_mtypes {
- char *name;
+ const char *name;
int token;
};
/* Various message types */
va_end(arg_ptr);
}
-char *res_to_str(int rcode)
+const char *res_to_str(int rcode)
{
if (rcode < r_first || rcode > r_last) {
- return "***UNKNOWN***";
+ return _("***UNKNOWN***");
} else {
return resources[rcode-r_first].name;
}
continue; /* get another destination */
}
if (token != T_EQUALS) {
- scan_err1(lc, "expected an =, got: %s", lc->str);
+ scan_err1(lc, _("expected an =, got: %s"), lc->str);
}
break;
}
token = lex_get_token(lc, T_ALL);
Dmsg1(200, "store_msgs dest=%s:\n", NPRT(dest));
if (token != T_EQUALS) {
- scan_err1(lc, "expected an =, got: %s", lc->str);
+ scan_err1(lc, _("expected an =, got: %s"), lc->str);
}
scan_types(lc, (MSGS *)(item->value), item->code, dest, NULL);
free_pool_memory(dest);
break;
default:
- scan_err1(lc, "Unknown item code: %d\n", item->code);
+ scan_err1(lc, _("Unknown item code: %d\n"), item->code);
break;
}
}
case T_IDENTIFIER:
case T_UNQUOTED_STRING:
if (!size_to_uint64(lc->str, lc->str_len, &uvalue)) {
- scan_err1(lc, "expected a size number, got: %s", lc->str);
+ scan_err1(lc, _("expected a size number, got: %s"), lc->str);
}
*(uint64_t *)(item->value) = uvalue;
break;
default:
- scan_err1(lc, "expected a size, got: %s", lc->str);
+ scan_err1(lc, _("expected a size, got: %s"), lc->str);
break;
}
scan_to_eol(lc);
}
}
if (!duration_to_utime(period, &utime)) {
- scan_err1(lc, "expected a time period, got: %s", period);
+ scan_err1(lc, _("expected a time period, got: %s"), period);
}
*(utime_t *)(item->value) = utime;
break;
default:
- scan_err1(lc, "expected a time period, got: %s", lc->str);
+ scan_err1(lc, _("expected a time period, got: %s"), lc->str);
break;
}
if (token != T_EOL) {
} else if (strcasecmp(lc->str, "no") == 0) {
*(int *)(item->value) &= ~(item->code);
} else {
- scan_err1(lc, "Expect a YES or NO, got: %s", lc->str);
+ scan_err1(lc, _("Expect a YES or NO, got: %s"), lc->str);
}
scan_to_eol(lc);
set_bit(index, res_all.hdr.item_present);
break;
}
if (token != T_IDENTIFIER) {
- scan_err1(lc, "Expected a Resource name identifier, got: %s", lc->str);
+ scan_err1(lc, _("Expected a Resource name identifier, got: %s"), lc->str);
/* NOT REACHED */
}
for (i=0; resources[i].name; i++)
break;
}
if (state == p_none) {
- scan_err1(lc, "expected resource name, got: %s", lc->str);
+ scan_err1(lc, _("expected resource name, got: %s"), lc->str);
/* NOT REACHED */
}
break;
break;
case T_IDENTIFIER:
if (level != 1) {
- scan_err1(lc, "not in resource definition: %s", lc->str);
+ scan_err1(lc, _("not in resource definition: %s"), lc->str);
/* NOT REACHED */
}
for (i=0; items[i].name; i++) {
token = lex_get_token(lc, T_ALL);
Dmsg1 (150, "in T_IDENT got token=%s\n", lex_tok_to_str(token));
if (token != T_EQUALS) {
- scan_err1(lc, "expected an equals, got: %s", lc->str);
+ scan_err1(lc, _("expected an equals, got: %s"), lc->str);
/* NOT REACHED */
}
}
if (i >= 0) {
Dmsg2(150, "level=%d id=%s\n", level, lc->str);
Dmsg1(150, "Keyword = %s\n", lc->str);
- scan_err1(lc, "Keyword \"%s\" not permitted in this resource.\n"
- "Perhaps you left the trailing brace off of the previous resource.", lc->str);
+ scan_err1(lc, _("Keyword \"%s\" not permitted in this resource.\n"
+ "Perhaps you left the trailing brace off of the previous resource."), lc->str);
/* NOT REACHED */
}
break;
break;
default:
- scan_err2(lc, "unexpected token %d %s in resource definition",
+ scan_err2(lc, _("unexpected token %d %s in resource definition"),
token, lex_tok_to_str(token));
/* NOT REACHED */
}
break;
default:
- scan_err1(lc, "Unknown parser state %d\n", state);
+ scan_err1(lc, _("Unknown parser state %d\n"), state);
/* NOT REACHED */
}
}
if (state != p_none) {
- scan_err0(lc, "End of conf file reached with unclosed resource.");
+ scan_err0(lc, _("End of conf file reached with unclosed resource."));
}
if (debug_level > 50 && pass == 2) {
int i;
* tables.
*/
struct res_items {
- char *name; /* Resource name i.e. Director, ... */
+ const char *name; /* Resource name i.e. Director, ... */
MSG_RES_HANDLER *handler; /* Routine storing the resource item */
void **value; /* Where to store the item */
int code; /* item code/additional info */
* resources that are available to this daemon.
*/
struct s_res {
- char *name; /* resource name */
+ const char *name; /* resource name */
struct res_items *items; /* list of resource keywords */
int rcode; /* code if needed */
RES *res_head; /* where to store it */
void free_resource(int type);
void init_resource(int type, struct res_items *item);
void save_resource(int type, struct res_items *item, int pass);
-char *res_to_str(int rcode);
+const char *res_to_str(int rcode);
/* Loop through each resource of type, returning in var */
#define foreach_res(var, type) \
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, const char *fmt, ...);
-void create_pid_file (char *dir, char *progname, int port);
-int delete_pid_file (char *dir, char *progname, int port);
+void create_pid_file (char *dir, const char *progname, int port);
+int delete_pid_file (char *dir, const 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);
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 max_retry_time, const 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,
+BSOCK * init_bsock (JCR *jcr, int sockfd, const char *who, char *ip,
int port, struct sockaddr_in *client_addr);
BSOCK * dup_bsock (BSOCK *bsock);
void term_bsock (BSOCK *bsock);
int bget_msg(BSOCK *sock);
/* bpipe.c */
-BPIPE * open_bpipe(char *prog, int wait, char *mode);
+BPIPE * open_bpipe(char *prog, int wait, const char *mode);
int close_wpipe(BPIPE *bpipe);
int close_bpipe(BPIPE *bpipe);
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);
+const char * lex_tok_to_str (int token);
int lex_get_token (LEX *lf, int expect);
/* message.c */
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 pm_strcat (POOLMEM **pm, const char *str);
+int pm_strcpy (POOLMEM **pm, const 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);
+POOLMEM *edit_job_codes(JCR *jcr, char *omsg, char *imsg, const char *to);
void set_working_directory(char *wd);
* Concatenate a string (str) onto a pool memory buffer pm
* Returns: length of concatenated string
*/
-int pm_strcat(POOLMEM **pm, char *str)
+int pm_strcat(POOLMEM **pm, const char *str)
{
int pmlen = strlen(*pm);
int len = strlen(str) + 1;
* Copy a string (str) into a pool memory buffer pm
* Returns: length of string copied
*/
-int pm_strcpy(POOLMEM **pm, char *str)
+int pm_strcpy(POOLMEM **pm, const char *str)
{
int len = strlen(str) + 1;
* to = recepients list
*
*/
-POOLMEM *edit_job_codes(JCR *jcr, char *omsg, char *imsg, char *to)
+POOLMEM *edit_job_codes(JCR *jcr, char *omsg, char *imsg, const char *to)
{
- char *p, *str;
+ char *p, *q;
+ const char *str;
char add[20];
char name[MAX_NAME_LENGTH];
int i;
bstrncpy(name, jcr->Job, sizeof(name));
/* There are three periods after the Job name */
for (i=0; i<3; i++) {
- if ((str=strrchr(name, '.')) != NULL) {
- *str = 0;
+ if ((q=strrchr(name, '.')) != NULL) {
+ *q = 0;
}
}
str = name;
/*
* Format a scanner error message
*/
-static void s_err(char *file, int line, LEX *lc, char *msg, ...)
+static void s_err(const char *file, int line, LEX *lc, const char *msg, ...)
{
JCR *jcr = (JCR *)(lc->caller_ctx);
va_list arg_ptr;
/* */
#undef VERSION
-#define VERSION "1.33.3"
+#define VERSION "1.33.4"
#define VSTRING "1"
-#define BDATE "16 Feb 2004"
-#define LSMDATE "16Feb04"
+#define BDATE "18 Feb 2004"
+#define LSMDATE "18Feb04"
/* Debug flags */
#undef DEBUG