Add const for Solaris' C++ compiler

git-svn-id: https://bacula.svn.sourceforge.net/svnroot/bacula/trunk@1058 91ce42f0-d328-0410-95d8-f526ca767f89

diff --git a/bacula/src/filed/job.c b/bacula/src/filed/job.c
index bc3f09a40e9953311e4419648070359cc70f27d8..b3890910bd9757ab9978415f7777dccbab09a9cc 100644 (file)
--- a/bacula/src/filed/job.c
+++ b/bacula/src/filed/job.c
@@ -50,13 +50,13 @@ static int verify_cmd(JCR *jcr);
 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 */
@@ -264,10 +264,10 @@ static int cancel_cmd(JCR *jcr)
         }
         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;
@@ -387,7 +387,7 @@ static int runafter_cmd(JCR *jcr)
    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;
@@ -1133,7 +1133,7 @@ static void filed_free_jcr(JCR *jcr)
  *  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;

diff --git a/bacula/src/filed/restore.c b/bacula/src/filed/restore.c
index 8b536647cb455a67303216e15b89ec488e2abe9b..6066677bdebb90494e2bb53d95b1bcc096abccf0 100644 (file)
--- a/bacula/src/filed/restore.c
+++ b/bacula/src/filed/restore.c
@@ -34,7 +34,7 @@ static char rec_header[] = "rechdr %ld %ld %ld %ld %ld";
 
 /* 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 */
@@ -366,7 +366,7 @@ ok_out:
 /*
  * 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";

diff --git a/bacula/src/filed/status.c b/bacula/src/filed/status.c
index 17c1e1a48bfe71f36056f63bb09321bda73bf7f5..4b668191a4b4abe46acf9f5adf6800aea8823b71 100755 (executable)
--- a/bacula/src/filed/status.c
+++ b/bacula/src/filed/status.c
@@ -34,8 +34,8 @@ extern struct s_last_job last_job;
 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);
 
 
@@ -46,7 +46,7 @@ static int privs = 0;
 /*
  * 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];
@@ -163,12 +163,12 @@ static void do_status(void sendit(char *msg, int len, void *sarg), void *arg)
    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"); 
@@ -245,7 +245,7 @@ static void  list_terminated_jobs(void sendit(char *msg, int len, void *sarg), v
 /*
  * 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;
 
@@ -333,13 +333,13 @@ struct s_win32_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;

diff --git a/bacula/src/findlib/bfile.c b/bacula/src/findlib/bfile.c
index 600b6d53491593d648f86d6c7ece4896d75dcf57..b3e75ef241718c59fc5e2922536562df23fccb26 100644 (file)
--- a/bacula/src/findlib/bfile.c
+++ b/bacula/src/findlib/bfile.c
@@ -48,7 +48,7 @@ int is_win32_stream(int stream)
    return 0;
 }
 
-char *stream_to_ascii(int stream)
+const char *stream_to_ascii(int stream)
 {
    static char buf[20];
 
@@ -79,7 +79,7 @@ char *stream_to_ascii(int stream)
       return "SHA1 signature";
    default:
       sprintf(buf, "%d", stream);
-      return buf;
+      return (const char *)buf;
    }
 }
 

diff --git a/bacula/src/findlib/bfile.h b/bacula/src/findlib/bfile.h
index 5356182c39a95bbe237cbe869ec64274ede1c358..66123fd5d4b38a2fce50b1824348d96c31e41510 100644 (file)
--- a/bacula/src/findlib/bfile.h
+++ b/bacula/src/findlib/bfile.h
@@ -35,50 +35,50 @@
 
 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 */

diff --git a/bacula/src/jcr.h b/bacula/src/jcr.h
index d9b04697708c74d4ea266bbcb222b41914d0743e..6d03a634c6cb8ada956635b6b2af0d3f22e6cb3f 100644 (file)
--- a/bacula/src/jcr.h
+++ b/bacula/src/jcr.h
@@ -297,7 +297,7 @@ extern void unlock_jcr_chain();
 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);

diff --git a/bacula/src/lib/attr.c b/bacula/src/lib/attr.c
index cec5a4d2bbd4a28dd3db988860a348c006de5d7c..4c5ae2d54f04967c0494b3f68586b70e9714e26e 100644 (file)
--- a/bacula/src/lib/attr.c
+++ b/bacula/src/lib/attr.c
@@ -129,7 +129,7 @@ void build_attr_output_fnames(JCR *jcr, ATTR *attr)
       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] == ':') {

diff --git a/bacula/src/lib/bnet.c b/bacula/src/lib/bnet.c
index f936cc4dc5555ec1447e32bf5bd19e14c2978330..eb7fab80d38356a37949c44d332e71fab958a2ae 100644 (file)
--- a/bacula/src/lib/bnet.c
+++ b/bacula/src/lib/bnet.c
@@ -502,7 +502,7 @@ extern int h_errno;         /* On error has one of the above */
 /*
  * Get human readable error for gethostbyname()
  */
-static char *gethost_strerror() 
+static const char *gethost_strerror() 
 {
    switch (h_errno) {
    case NETDB_INTERNAL:
@@ -579,7 +579,7 @@ Wanted %d got %d bytes for s_addr.\n"), sizeof(inaddr.s_addr), hp->h_length);
  *  ***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 */
@@ -636,7 +636,7 @@ bnet_open(JCR *jcr, char *name, char *host, char *service, int port, int *fatal)
  * 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;
@@ -823,7 +823,7 @@ char *bnet_sig_to_ascii(BSOCK *bs)
  *  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));

diff --git a/bacula/src/lib/bnet_server.c b/bacula/src/lib/bnet_server.c
index b050d88405b61658aa41abddcffa19cd30b92bab..45c0dd0448819bb72e4e5e40717f1bcbeb560177 100644 (file)
--- a/bacula/src/lib/bnet_server.c
+++ b/bacula/src/lib/bnet_server.c
@@ -172,7 +172,7 @@ bnet_thread_server(char *bind_addr, int port, int max_clients, workq_t *client_w
       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);

diff --git a/bacula/src/lib/bpipe.c b/bacula/src/lib/bpipe.c
index 831731d5b57865334eb7f78f529bddab51ccb9ef..cc176f031c7df341d33883e241ae867dc94bb11e 100644 (file)
--- a/bacula/src/lib/bpipe.c
+++ b/bacula/src/lib/bpipe.c
@@ -41,7 +41,7 @@ static void build_argc_argv(char *cmd, int *bargc, char *bargv[], int max_arg);
  *   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;

diff --git a/bacula/src/lib/bsys.c b/bacula/src/lib/bsys.c
index 57a7c02ab0536b88ea307da1997f8ecc01c5f8d7..014dfa44bb7120985f33730c3cfd714f1cd38f4d 100644 (file)
--- a/bacula/src/lib/bsys.c
+++ b/bacula/src/lib/bsys.c
@@ -290,7 +290,7 @@ static int del_pid_file_ok = FALSE;
 /*
  * 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;
@@ -332,7 +332,7 @@ void create_pid_file(char *dir, char *progname, int port)
 /*
  * 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);

diff --git a/bacula/src/lib/edit.c b/bacula/src/lib/edit.c
index 11a2e329247165701563ced33ba34a8d4ff16e79..a55de70e081f680f33dec53b53f58c5d583828dd 100644 (file)
--- a/bacula/src/lib/edit.c
+++ b/bacula/src/lib/edit.c
@@ -109,9 +109,9 @@ int duration_to_utime(char *str, utime_t *value)
     *   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;

diff --git a/bacula/src/lib/jcr.c b/bacula/src/lib/jcr.c
index 068366cd5a1c2f7ff5750bcaf9ab55802c2fe9e0..1bb7e5d810fe70abbb76ab1c72ec5be1fd37cdab 100755 (executable)
--- a/bacula/src/lib/jcr.c
+++ b/bacula/src/lib/jcr.c
@@ -227,7 +227,7 @@ static void free_common_jcr(JCR *jcr)
  * 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);
 
@@ -540,7 +540,7 @@ static void jcr_timeout_check(watchdog_t *self)
 /*
  * Timeout signal comes here
  */
-void timeout_handler(int sig)
+static void timeout_handler(int sig)
 {
    return;                           /* thus interrupting the function */
 }

diff --git a/bacula/src/lib/lex.c b/bacula/src/lib/lex.c
index b2a99ea1c287d60f31bc8059db77088bfdb4db0d..e9cf48493619bbb96906d457fa9dc3c38a05eabd 100644 (file)
--- a/bacula/src/lib/lex.c
+++ b/bacula/src/lib/lex.c
@@ -46,7 +46,7 @@ void scan_to_eol(LEX *lc)
 /*
  * 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];
@@ -211,7 +211,7 @@ static void begin_str(LEX *lf, int ch)
 }
 
 #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";
@@ -230,7 +230,7 @@ static char *lex_state_to_str(int state)
  * 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";
@@ -256,13 +256,13 @@ static uint32_t scan_pint(LEX *lf, char *str)
 {
    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 */
       }
    }
@@ -489,7 +489,7 @@ lex_get_token(LEX *lf, int expect)
       } 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;
@@ -503,7 +503,7 @@ lex_get_token(LEX *lf, int expect)
 
    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;
@@ -511,7 +511,7 @@ lex_get_token(LEX *lf, int expect)
       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 {
@@ -522,7 +522,7 @@ lex_get_token(LEX *lf, int expect)
    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;
@@ -530,7 +530,7 @@ lex_get_token(LEX *lf, int expect)
       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 {
@@ -540,11 +540,11 @@ lex_get_token(LEX *lf, int expect)
 
    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;
       }
@@ -552,7 +552,7 @@ lex_get_token(LEX *lf, int expect)
 
    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 {

diff --git a/bacula/src/lib/lex.h b/bacula/src/lib/lex.h
index f063797be637268d2aa0ce3fa958b8302613e4bf..199d34c1106baccc36624b66a7901a38b94e0ae2 100644 (file)
--- a/bacula/src/lib/lex.h
+++ b/bacula/src/lib/lex.h
@@ -32,38 +32,38 @@
 #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 {
@@ -78,32 +78,32 @@ 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)

diff --git a/bacula/src/lib/message.c b/bacula/src/lib/message.c
index 03aab84941932d760f53197a8f39df546aedec2a..803dff064076a30716ce7f006c4f247673dfb10d 100755 (executable)
--- a/bacula/src/lib/message.c
+++ b/bacula/src/lib/message.c
@@ -41,7 +41,7 @@ char *working_directory = NULL;       /* working directory path stored here */
 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;
@@ -941,7 +941,7 @@ Jmsg(JCR *jcr, int type, int level, const char *fmt,...)
     va_list   arg_ptr;
     int len;
     MSGS *msgs;
-    char *job;
+    const char *job;
 
     
     Dmsg1(800, "Enter Jmsg type=%d\n", type);

diff --git a/bacula/src/lib/message.h b/bacula/src/lib/message.h
index f891802341964cbf5ee47e6c6828b66c294ad99d..4bd66244d1a4663dfca636599f9a14762f26ee67 100644 (file)
--- a/bacula/src/lib/message.h
+++ b/bacula/src/lib/message.h
@@ -81,7 +81,7 @@ enum {
    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 ! */

diff --git a/bacula/src/lib/parse_conf.c b/bacula/src/lib/parse_conf.c
index fddab60bddfca2cfd8cba6d466522d142af93c92..b21560d6283c4f332398b02ceb79ae2f7e59ce02 100755 (executable)
--- a/bacula/src/lib/parse_conf.c
+++ b/bacula/src/lib/parse_conf.c
@@ -72,7 +72,7 @@ extern struct s_res resources[];
 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
 
@@ -107,7 +107,7 @@ struct res_items msgs_items[] = {
 };
 
 struct s_mtypes {      
-   char *name;
+   const char *name;
    int token;  
 };
 /* Various message types */
@@ -139,10 +139,10 @@ static void prtmsg(void *sock, char *fmt, ...)
    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;
    }
@@ -233,7 +233,7 @@ void store_msgs(LEX *lc, struct res_items *item, int index, int pass)
               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;
         }
@@ -252,7 +252,7 @@ void store_msgs(LEX *lc, struct res_items *item, int index, int pass)
         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);
@@ -260,7 +260,7 @@ void store_msgs(LEX *lc, struct res_items *item, int index, int pass)
         break;
 
       default:
-         scan_err1(lc, "Unknown item code: %d\n", item->code);
+         scan_err1(lc, _("Unknown item code: %d\n"), item->code);
         break;
       }
    }
@@ -518,12 +518,12 @@ void store_size(LEX *lc, struct res_items *item, int index, int pass)
    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);
@@ -556,12 +556,12 @@ void store_time(LEX *lc, struct res_items *item, int index, int pass)
         }
       }
       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) {
@@ -580,7 +580,7 @@ void store_yesno(LEX *lc, struct res_items *item, int index, int pass)
    } 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);
@@ -682,7 +682,7 @@ parse_config(char *cf)
                  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++)
@@ -694,7 +694,7 @@ parse_config(char *cf)
                     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;
@@ -705,7 +705,7 @@ parse_config(char *cf)
                     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++) {
@@ -716,7 +716,7 @@ parse_config(char *cf)
                              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 */
                              }
                           }
@@ -730,8 +730,8 @@ parse_config(char *cf)
                     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;
@@ -747,18 +747,18 @@ parse_config(char *cf)
                     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;

diff --git a/bacula/src/lib/parse_conf.h b/bacula/src/lib/parse_conf.h
index 78c1beba24ddc6db1f105606a98a94394ae3e021..fe4be0fc048f0e926f62b96f96c6a78eec70b7bb 100644 (file)
--- a/bacula/src/lib/parse_conf.h
+++ b/bacula/src/lib/parse_conf.h
@@ -30,7 +30,7 @@ typedef void (MSG_RES_HANDLER)(LEX *lc, struct res_items *item, int index, int p
  * 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 */
@@ -63,7 +63,7 @@ struct RES {
  * 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 */
@@ -109,7 +109,7 @@ void dump_resource(int type, RES *res, void sendmsg(void *sock, char *fmt, ...),
 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) \

diff --git a/bacula/src/lib/protos.h b/bacula/src/lib/protos.h
index 63cb677fc71984b2f5354b2dbddf2338a1ad3bd6..87588cece8eebf2dbbed3c8fbc8962f1b86d70b9 100644 (file)
--- a/bacula/src/lib/protos.h
+++ b/bacula/src/lib/protos.h
@@ -50,8 +50,8 @@ 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, 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);
@@ -69,10 +69,10 @@ 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 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);
@@ -89,7 +89,7 @@ void       bnet_suppress_error_messages(BSOCK *bsock, int flag);
 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);
 
@@ -131,7 +131,7 @@ 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);
+const char *  lex_tok_to_str     (int token);
 int       lex_get_token          (LEX *lf, int expect);
 
 /* message.c */
@@ -188,14 +188,14 @@ 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              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);
 
 

diff --git a/bacula/src/lib/util.c b/bacula/src/lib/util.c
index 3e41d4fd8a7b030eb21d59ee7aff284a7eddf24e..8f30486689ee05d9a7dec58ff1fbf0c15027a3b7 100644 (file)
--- a/bacula/src/lib/util.c
+++ b/bacula/src/lib/util.c
@@ -117,7 +117,7 @@ char *encode_time(time_t time, char *buf)
  * 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;
@@ -132,7 +132,7 @@ int pm_strcat(POOLMEM **pm, char *str)
  * 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;
 
@@ -493,9 +493,10 @@ void make_session_key(char *key, char *seed, int mode)
  *  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;
@@ -534,8 +535,8 @@ POOLMEM *edit_job_codes(JCR *jcr, char *omsg, char *imsg, char *to)
             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;

diff --git a/bacula/src/stored/parse_bsr.c b/bacula/src/stored/parse_bsr.c
index 7805c1c9d9685428e5f77bb8b7607b4fdc0d1372..3e469dadfea5078d25ea2740f65e74a3b5c8d375 100755 (executable)
--- a/bacula/src/stored/parse_bsr.c
+++ b/bacula/src/stored/parse_bsr.c
@@ -92,7 +92,7 @@ static BSR *new_bsr()
 /*
  * 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;

diff --git a/bacula/src/version.h b/bacula/src/version.h
index 9a18a84bfb2c36484118c3257685423e0a424e7b..d63412bcd551e2e7176a7df3cc6e93ee31bba88d 100644 (file)
--- a/bacula/src/version.h
+++ b/bacula/src/version.h
@@ -1,9 +1,9 @@
 /* */
 #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