--- /dev/null
+/*
+ * Manipulation routines for Job Control Records
+ *
+ * Kern E. Sibbald, December 2000
+ *
+ * Version $Id$
+ *
+ * These routines are thread safe.
+ *
+ */
+/*
+ Copyright (C) 2000-2003 Kern Sibbald and John Walker
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public
+ License along with this program; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA.
+
+ */
+
+#include "bacula.h"
+#include "jcr.h"
+
+/* External variables we reference */
+extern time_t watchdog_time;
+
+/* Forward referenced functions */
+static void timeout_handler(int sig);
+static void jcr_timeout_check(watchdog_t *self);
+
+int num_jobs_run;
+dlist *last_jobs = NULL;
+static const int max_last_jobs = 10;
+
+static JCR *jobs = NULL; /* pointer to JCR chain */
+static brwlock_t lock; /* lock for last jobs and JCR chain */
+
+void init_last_jobs_list()
+{
+ int errstat;
+ struct s_last_job *job_entry = NULL;
+ if (!last_jobs) {
+ last_jobs = new dlist(job_entry, &job_entry->link);
+ if ((errstat=rwl_init(&lock)) != 0) {
+ Emsg1(M_ABORT, 0, _("Unable to initialize jcr_chain lock. ERR=%s\n"),
+ strerror(errstat));
+ }
+ }
+
+}
+
+void term_last_jobs_list()
+{
+ if (last_jobs) {
+ while (!last_jobs->empty()) {
+ void *je = last_jobs->first();
+ last_jobs->remove(je);
+ free(je);
+ }
+ delete last_jobs;
+ last_jobs = NULL;
+ rwl_destroy(&lock);
+ }
+}
+
+void read_last_jobs_list(int fd, uint64_t addr)
+{
+ struct s_last_job *je, job;
+ uint32_t num;
+
+ Dmsg1(100, "read_last_jobs seek to %d\n", (int)addr);
+ if (addr == 0 || lseek(fd, addr, SEEK_SET) < 0) {
+ return;
+ }
+ if (read(fd, &num, sizeof(num)) != sizeof(num)) {
+ return;
+ }
+ Dmsg1(100, "Read num_items=%d\n", num);
+ if (num > 4 * max_last_jobs) { /* sanity check */
+ return;
+ }
+ for ( ; num; num--) {
+ if (read(fd, &job, sizeof(job)) != sizeof(job)) {
+ Dmsg1(000, "Read job entry. ERR=%s\n", strerror(errno));
+ return;
+ }
+ if (job.JobId > 0) {
+ je = (struct s_last_job *)malloc(sizeof(struct s_last_job));
+ memcpy((char *)je, (char *)&job, sizeof(job));
+ if (!last_jobs) {
+ init_last_jobs_list();
+ }
+ last_jobs->append(je);
+ if (last_jobs->size() > max_last_jobs) {
+ je = (struct s_last_job *)last_jobs->first();
+ last_jobs->remove(je);
+ free(je);
+ }
+ }
+ }
+}
+
+uint64_t write_last_jobs_list(int fd, uint64_t addr)
+{
+ struct s_last_job *je;
+ uint32_t num;
+
+ Dmsg1(100, "write_last_jobs seek to %d\n", (int)addr);
+ if (lseek(fd, addr, SEEK_SET) < 0) {
+ return 0;
+ }
+ if (last_jobs) {
+ /* First record is number of entires */
+ num = last_jobs->size();
+ if (write(fd, &num, sizeof(num)) != sizeof(num)) {
+ Dmsg1(000, "Error writing num_items: ERR=%s\n", strerror(errno));
+ return 0;
+ }
+ foreach_dlist(je, last_jobs) {
+ if (write(fd, je, sizeof(struct s_last_job)) != sizeof(struct s_last_job)) {
+ Dmsg1(000, "Error writing job: ERR=%s\n", strerror(errno));
+ return 0;
+ }
+ }
+ }
+ /* Return current address */
+ ssize_t stat = lseek(fd, 0, SEEK_CUR);
+ if (stat < 0) {
+ stat = 0;
+ }
+ return stat;
+
+}
+
+void lock_last_jobs_list()
+{
+ /* Use jcr chain mutex */
+ lock_jcr_chain();
+}
+
+void unlock_last_jobs_list()
+{
+ /* Use jcr chain mutex */
+ unlock_jcr_chain();
+}
+
+/*
+ * Push a subroutine address into the job end callback stack
+ */
+void job_end_push(JCR *jcr, void job_end_cb(JCR *jcr))
+{
+ jcr->job_end_push.prepend((void *)job_end_cb);
+}
+
+/* Pop each job_end subroutine and call it */
+static void job_end_pop(JCR *jcr)
+{
+ void (*job_end_cb)(JCR *jcr);
+ for (int i=0; i<jcr->job_end_push.size(); i++) {
+ job_end_cb = (void (*)(JCR *))jcr->job_end_push.get(i);
+ job_end_cb(jcr);
+ }
+}
+
+/*
+ * Create a Job Control Record and link it into JCR chain
+ * Returns newly allocated JCR
+ * Note, since each daemon has a different JCR, he passes
+ * us the size.
+ */
+JCR *new_jcr(int size, JCR_free_HANDLER *daemon_free_jcr)
+{
+ JCR *jcr;
+ MQUEUE_ITEM *item = NULL;
+ struct sigaction sigtimer;
+
+ Dmsg0(400, "Enter new_jcr\n");
+ jcr = (JCR *)malloc(size);
+ memset(jcr, 0, size);
+ jcr->msg_queue = new dlist(item, &item->link);
+ jcr->job_end_push.init(1, false);
+ jcr->sched_time = time(NULL);
+ jcr->daemon_free_jcr = daemon_free_jcr; /* plug daemon free routine */
+ jcr->use_count = 1;
+ pthread_mutex_init(&(jcr->mutex), NULL);
+ jcr->JobStatus = JS_Created; /* ready to run */
+ jcr->VolumeName = get_pool_memory(PM_FNAME);
+ jcr->VolumeName[0] = 0;
+ jcr->errmsg = get_pool_memory(PM_MESSAGE);
+ jcr->errmsg[0] = 0;
+ /* Setup some dummy values */
+ jcr->Job[0] = 0; /* no job name by default */
+ jcr->JobId = 0;
+ jcr->JobType = JT_ADMIN;
+ jcr->JobLevel = L_NONE;
+ jcr->JobStatus = JS_Created;
+
+ sigtimer.sa_flags = 0;
+ sigtimer.sa_handler = timeout_handler;
+ sigfillset(&sigtimer.sa_mask);
+ sigaction(TIMEOUT_SIGNAL, &sigtimer, NULL);
+
+ lock_jcr_chain();
+ jcr->prev = NULL;
+ jcr->next = jobs;
+ if (jobs) {
+ jobs->prev = jcr;
+ }
+ jobs = jcr;
+ unlock_jcr_chain();
+ return jcr;
+}
+
+
+/*
+ * Remove a JCR from the chain
+ * NOTE! The chain must be locked prior to calling
+ * this routine.
+ */
+static void remove_jcr(JCR *jcr)
+{
+ Dmsg0(400, "Enter remove_jcr\n");
+ if (!jcr) {
+ Emsg0(M_ABORT, 0, "NULL jcr.\n");
+ }
+ if (!jcr->prev) { /* if no prev */
+ jobs = jcr->next; /* set new head */
+ } else {
+ jcr->prev->next = jcr->next; /* update prev */
+ }
+ if (jcr->next) {
+ jcr->next->prev = jcr->prev;
+ }
+ Dmsg0(400, "Leave remove_jcr\n");
+}
+
+/*
+ * Free stuff common to all JCRs. N.B. Be careful to include only
+ * generic stuff in the common part of the jcr.
+ */
+static void free_common_jcr(JCR *jcr)
+{
+ struct s_last_job *je, last_job;
+
+ /* Keep some statistics */
+ switch (jcr->JobType) {
+ case JT_BACKUP:
+ case JT_VERIFY:
+ case JT_RESTORE:
+ case JT_ADMIN:
+ num_jobs_run++;
+ last_job.JobType = jcr->JobType;
+ last_job.JobId = jcr->JobId;
+ last_job.VolSessionId = jcr->VolSessionId;
+ last_job.VolSessionTime = jcr->VolSessionTime;
+ bstrncpy(last_job.Job, jcr->Job, sizeof(last_job.Job));
+ last_job.JobFiles = jcr->JobFiles;
+ last_job.JobBytes = jcr->JobBytes;
+ last_job.JobStatus = jcr->JobStatus;
+ last_job.JobLevel = jcr->JobLevel;
+ last_job.start_time = jcr->start_time;
+ last_job.end_time = time(NULL);
+ /* Keep list of last jobs, but not Console where JobId==0 */
+ if (last_job.JobId > 0) {
+ je = (struct s_last_job *)malloc(sizeof(struct s_last_job));
+ memcpy((char *)je, (char *)&last_job, sizeof(last_job));
+ if (!last_jobs) {
+ init_last_jobs_list();
+ }
+ last_jobs->append(je);
+ if (last_jobs->size() > max_last_jobs) {
+ je = (struct s_last_job *)last_jobs->first();
+ last_jobs->remove(je);
+ free(je);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ pthread_mutex_destroy(&jcr->mutex);
+
+ delete jcr->msg_queue;
+ close_msg(jcr); /* close messages for this job */
+
+ /* do this after closing messages */
+ if (jcr->client_name) {
+ free_pool_memory(jcr->client_name);
+ jcr->client_name = NULL;
+ }
+
+ if (jcr->sd_auth_key) {
+ free(jcr->sd_auth_key);
+ jcr->sd_auth_key = NULL;
+ }
+ if (jcr->VolumeName) {
+ free_pool_memory(jcr->VolumeName);
+ jcr->VolumeName = NULL;
+ }
+
+ if (jcr->dir_bsock) {
+ bnet_close(jcr->dir_bsock);
+ jcr->dir_bsock = NULL;
+ }
+ if (jcr->errmsg) {
+ free_pool_memory(jcr->errmsg);
+ jcr->errmsg = NULL;
+ }
+ if (jcr->where) {
+ free(jcr->where);
+ jcr->where = NULL;
+ }
+ if (jcr->cached_path) {
+ free_pool_memory(jcr->cached_path);
+ jcr->cached_path = NULL;
+ jcr->cached_pnl = 0;
+ }
+ free_getuser_cache();
+ free_getgroup_cache();
+ free(jcr);
+}
+
+/*
+ * Global routine to free a jcr
+ */
+#ifdef DEBUG
+void b_free_jcr(const char *file, int line, JCR *jcr)
+{
+ Dmsg3(400, "Enter free_jcr 0x%x from %s:%d\n", jcr, file, line);
+
+#else
+
+void free_jcr(JCR *jcr)
+{
+
+ Dmsg1(400, "Enter free_jcr 0x%x\n", jcr);
+
+#endif
+
+ lock_jcr_chain();
+ jcr->use_count--; /* decrement use count */
+ if (jcr->use_count < 0) {
+ Emsg2(M_ERROR, 0, _("JCR use_count=%d JobId=%d\n"),
+ jcr->use_count, jcr->JobId);
+ }
+ Dmsg3(400, "Dec free_jcr 0x%x use_count=%d jobid=%d\n", jcr, jcr->use_count, jcr->JobId);
+ if (jcr->use_count > 0) { /* if in use */
+ unlock_jcr_chain();
+ Dmsg2(400, "free_jcr 0x%x use_count=%d\n", jcr, jcr->use_count);
+ return;
+ }
+ dequeue_messages(jcr);
+ remove_jcr(jcr);
+ job_end_pop(jcr); /* pop and call hooked routines */
+
+ Dmsg1(400, "End job=%d\n", jcr->JobId);
+ if (jcr->daemon_free_jcr) {
+ jcr->daemon_free_jcr(jcr); /* call daemon free routine */
+ }
+
+ free_common_jcr(jcr);
+
+ close_msg(NULL); /* flush any daemon messages */
+ unlock_jcr_chain();
+ Dmsg0(400, "Exit free_jcr\n");
+}
+
+
+/*
+ * Global routine to free a jcr
+ * JCR chain is already locked
+ */
+void free_locked_jcr(JCR *jcr)
+{
+ jcr->use_count--; /* decrement use count */
+ Dmsg2(400, "Dec free_locked_jcr 0x%x use_count=%d\n", jcr, jcr->use_count);
+ if (jcr->use_count > 0) { /* if in use */
+ return;
+ }
+ remove_jcr(jcr);
+ jcr->daemon_free_jcr(jcr); /* call daemon free routine */
+ free_common_jcr(jcr);
+}
+
+
+
+/*
+ * Given a JobId, find the JCR
+ * Returns: jcr on success
+ * NULL on failure
+ */
+JCR *get_jcr_by_id(uint32_t JobId)
+{
+ JCR *jcr;
+
+ lock_jcr_chain(); /* lock chain */
+ for (jcr = jobs; jcr; jcr=jcr->next) {
+ if (jcr->JobId == JobId) {
+ P(jcr->mutex);
+ jcr->use_count++;
+ V(jcr->mutex);
+ Dmsg2(400, "Inc get_jcr 0x%x use_count=%d\n", jcr, jcr->use_count);
+ break;
+ }
+ }
+ unlock_jcr_chain();
+ return jcr;
+}
+
+/*
+ * Given a SessionId and SessionTime, find the JCR
+ * Returns: jcr on success
+ * NULL on failure
+ */
+JCR *get_jcr_by_session(uint32_t SessionId, uint32_t SessionTime)
+{
+ JCR *jcr;
+
+ lock_jcr_chain();
+ for (jcr = jobs; jcr; jcr=jcr->next) {
+ if (jcr->VolSessionId == SessionId &&
+ jcr->VolSessionTime == SessionTime) {
+ P(jcr->mutex);
+ jcr->use_count++;
+ V(jcr->mutex);
+ Dmsg2(400, "Inc get_jcr 0x%x use_count=%d\n", jcr, jcr->use_count);
+ break;
+ }
+ }
+ unlock_jcr_chain();
+ return jcr;
+}
+
+
+/*
+ * Given a Job, find the JCR
+ * compares on the number of characters in Job
+ * thus allowing partial matches.
+ * Returns: jcr on success
+ * NULL on failure
+ */
+JCR *get_jcr_by_partial_name(char *Job)
+{
+ JCR *jcr;
+ int len;
+
+ if (!Job) {
+ return NULL;
+ }
+ lock_jcr_chain();
+ len = strlen(Job);
+ for (jcr = jobs; jcr; jcr=jcr->next) {
+ if (strncmp(Job, jcr->Job, len) == 0) {
+ P(jcr->mutex);
+ jcr->use_count++;
+ V(jcr->mutex);
+ Dmsg2(400, "Inc get_jcr 0x%x use_count=%d\n", jcr, jcr->use_count);
+ break;
+ }
+ }
+ unlock_jcr_chain();
+ return jcr;
+}
+
+
+/*
+ * Given a Job, find the JCR
+ * requires an exact match of names.
+ * Returns: jcr on success
+ * NULL on failure
+ */
+JCR *get_jcr_by_full_name(char *Job)
+{
+ JCR *jcr;
+
+ if (!Job) {
+ return NULL;
+ }
+ lock_jcr_chain();
+ for (jcr = jobs; jcr; jcr=jcr->next) {
+ if (strcmp(jcr->Job, Job) == 0) {
+ P(jcr->mutex);
+ jcr->use_count++;
+ V(jcr->mutex);
+ Dmsg2(400, "Inc get_jcr 0x%x use_count=%d\n", jcr, jcr->use_count);
+ break;
+ }
+ }
+ unlock_jcr_chain();
+ return jcr;
+}
+
+void set_jcr_job_status(JCR *jcr, int JobStatus)
+{
+ /*
+ * For a set of errors, ... keep the current status
+ * so it isn't lost. For all others, set it.
+ */
+ switch (jcr->JobStatus) {
+ case JS_ErrorTerminated:
+ case JS_Error:
+ case JS_FatalError:
+ case JS_Differences:
+ case JS_Canceled:
+ break;
+ default:
+ jcr->JobStatus = JobStatus;
+ }
+}
+
+/*
+ * Lock the chain
+ */
+void lock_jcr_chain()
+{
+ int errstat;
+ if ((errstat=rwl_writelock(&lock)) != 0) {
+ Emsg1(M_ABORT, 0, "rwl_writelock failure. ERR=%s\n",
+ strerror(errstat));
+ }
+}
+
+/*
+ * Unlock the chain
+ */
+void unlock_jcr_chain()
+{
+ int errstat;
+ if ((errstat=rwl_writeunlock(&lock)) != 0) {
+ Emsg1(M_ABORT, 0, "rwl_writeunlock failure. ERR=%s\n",
+ strerror(errstat));
+ }
+}
+
+
+JCR *get_next_jcr(JCR *prev_jcr)
+{
+ JCR *jcr;
+
+ if (prev_jcr == NULL) {
+ jcr = jobs;
+ } else {
+ jcr = prev_jcr->next;
+ }
+ if (jcr) {
+ P(jcr->mutex);
+ jcr->use_count++;
+ V(jcr->mutex);
+ Dmsg2(400, "Inc get_next_jcr 0x%x use_count=%d\n", jcr, jcr->use_count);
+ }
+ return jcr;
+}
+
+bool init_jcr_subsystem(void)
+{
+ watchdog_t *wd = new_watchdog();
+
+ wd->one_shot = false;
+ wd->interval = 30; /* FIXME: should be configurable somewhere, even
+ if only with a #define */
+ wd->callback = jcr_timeout_check;
+
+ register_watchdog(wd);
+
+ return true;
+}
+
+static void jcr_timeout_check(watchdog_t *self)
+{
+ JCR *jcr;
+ BSOCK *fd;
+ time_t timer_start;
+
+ Dmsg0(400, "Start JCR timeout checks\n");
+
+ /* Walk through all JCRs checking if any one is
+ * blocked for more than specified max time.
+ */
+ lock_jcr_chain();
+ foreach_jcr(jcr) {
+ free_locked_jcr(jcr); /* OK to free now cuz chain is locked */
+ if (jcr->JobId == 0) {
+ continue;
+ }
+ fd = jcr->store_bsock;
+ if (fd) {
+ timer_start = fd->timer_start;
+ if (timer_start && (watchdog_time - timer_start) > fd->timeout) {
+ fd->timer_start = 0; /* turn off timer */
+ fd->timed_out = TRUE;
+ Jmsg(jcr, M_ERROR, 0, _(
+"Watchdog sending kill after %d secs to thread stalled reading Storage daemon.\n"),
+ watchdog_time - timer_start);
+ pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL);
+ }
+ }
+ fd = jcr->file_bsock;
+ if (fd) {
+ timer_start = fd->timer_start;
+ if (timer_start && (watchdog_time - timer_start) > fd->timeout) {
+ fd->timer_start = 0; /* turn off timer */
+ fd->timed_out = TRUE;
+ Jmsg(jcr, M_ERROR, 0, _(
+"Watchdog sending kill after %d secs to thread stalled reading File daemon.\n"),
+ watchdog_time - timer_start);
+ pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL);
+ }
+ }
+ fd = jcr->dir_bsock;
+ if (fd) {
+ timer_start = fd->timer_start;
+ if (timer_start && (watchdog_time - timer_start) > fd->timeout) {
+ fd->timer_start = 0; /* turn off timer */
+ fd->timed_out = TRUE;
+ Jmsg(jcr, M_ERROR, 0, _(
+"Watchdog sending kill after %d secs to thread stalled reading Director.\n"),
+ watchdog_time - timer_start);
+ pthread_kill(jcr->my_thread_id, TIMEOUT_SIGNAL);
+ }
+ }
+
+ }
+ unlock_jcr_chain();
+
+ Dmsg0(400, "Finished JCR timeout checks\n");
+}
+
+/*
+ * Timeout signal comes here
+ */
+static void timeout_handler(int sig)
+{
+ return; /* thus interrupting the function */
+}
--- /dev/null
+/*
+ * Bacula message handling routines
+ *
+ * Kern Sibbald, April 2000
+ *
+ * Version $Id$
+ *
+ */
+
+/*
+ Copyright (C) 2000-2003 Kern Sibbald and John Walker
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public
+ License along with this program; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA.
+
+ */
+
+
+#include "bacula.h"
+#include "jcr.h"
+
+#define FULL_LOCATION 1 /* set for file:line in Debug messages */
+
+/*
+ * This is where we define "Globals" because all the
+ * daemons include this file.
+ */
+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 */
+const char *version = VERSION " (" BDATE ")";
+char my_name[30]; /* daemon name is stored here */
+char *exepath = (char *)NULL;
+char *exename = (char *)NULL;
+int console_msg_pending = 0;
+char con_fname[500]; /* Console filename */
+FILE *con_fd = NULL; /* Console file descriptor */
+brwlock_t con_lock; /* Console lock structure */
+
+#ifdef HAVE_POSTGRESQL
+char catalog_db[] = "PostgreSQL";
+#else
+#ifdef HAVE_MYSQL
+char catalog_db[] = "MySQL";
+#else
+#ifdef HAVE_SQLITE
+char catalog_db[] = "SQLite";
+#else
+char catalog_db[] = "Internal";
+#endif
+#endif
+#endif
+
+const char *host_os = HOST_OS;
+const char *distname = DISTNAME;
+const char *distver = DISTVER;
+static FILE *trace_fd = NULL;
+#ifdef HAVE_WIN32
+static bool trace = true;
+#else
+static bool trace = false;
+#endif
+
+/* Forward referenced functions */
+
+/* Imported functions */
+
+
+/* Static storage */
+
+static MSGS *daemon_msgs; /* global messages */
+
+/*
+ * Set daemon name. Also, find canonical execution
+ * path. Note, exepath has spare room for tacking on
+ * the exename so that we can reconstruct the full name.
+ *
+ * Note, this routine can get called multiple times
+ * The second time is to put the name as found in the
+ * Resource record. On the second call, generally,
+ * argv is NULL to avoid doing the path code twice.
+ */
+#define BTRACE_EXTRA 20
+void my_name_is(int argc, char *argv[], const char *name)
+{
+ char *l, *p, *q;
+ char cpath[400], npath[400];
+ int len;
+
+ bstrncpy(my_name, name, sizeof(my_name));
+ if (argc>0 && argv && argv[0]) {
+ /* strip trailing filename and save exepath */
+ for (l=p=argv[0]; *p; p++) {
+ if (*p == '/') {
+ l = p; /* set pos of last slash */
+ }
+ }
+ if (*l == '/') {
+ l++;
+ } else {
+ l = argv[0];
+#if defined(HAVE_CYGWIN) || defined(HAVE_WIN32)
+ /* On Windows allow c: junk */
+ if (l[1] == ':') {
+ l += 2;
+ }
+#endif
+ }
+ len = strlen(l) + 1;
+ if (exename) {
+ free(exename);
+ }
+ exename = (char *)malloc(len);
+ strcpy(exename, l);
+
+ if (exepath) {
+ free(exepath);
+ }
+ exepath = (char *)malloc(strlen(argv[0]) + 1 + len);
+ for (p=argv[0],q=exepath; p < l; ) {
+ *q++ = *p++;
+ }
+ *q = 0;
+ Dmsg1(200, "exepath=%s\n", exepath);
+ if (strchr(exepath, '.') || exepath[0] != '/') {
+ npath[0] = 0;
+ if (getcwd(cpath, sizeof(cpath))) {
+ if (chdir(exepath) == 0) {
+ if (!getcwd(npath, sizeof(npath))) {
+ npath[0] = 0;
+ }
+ chdir(cpath);
+ }
+ if (npath[0]) {
+ free(exepath);
+ exepath = (char *)malloc(strlen(npath) + 1 + len);
+ strcpy(exepath, npath);
+ }
+ }
+ Dmsg1(200, "Normalized exepath=%s\n", exepath);
+ }
+ }
+}
+
+/*
+ * Initialize message handler for a daemon or a Job
+ * We make a copy of the MSGS resource passed, so it belows
+ * to the job or daemon and thus can be modified.
+ *
+ * NULL for jcr -> initialize global messages for daemon
+ * non-NULL -> initialize jcr using Message resource
+ */
+void
+init_msg(JCR *jcr, MSGS *msg)
+{
+ DEST *d, *dnew, *temp_chain = NULL;
+ int i;
+
+ if (jcr == NULL && msg == NULL) {
+ init_last_jobs_list();
+ }
+
+#ifndef HAVE_WIN32
+ /*
+ * Make sure we have fd's 0, 1, 2 open
+ * If we don't do this one of our sockets may open
+ * there and if we then use stdout, it could
+ * send total garbage to our socket.
+ *
+ */
+ int fd;
+ fd = open("/dev/null", O_RDONLY, 0644);
+ if (fd > 2) {
+ close(fd);
+ } else {
+ for(i=1; fd + i <= 2; i++) {
+ dup2(fd, fd+i);
+ }
+ }
+
+#endif
+ /*
+ * If msg is NULL, initialize global chain for STDOUT and syslog
+ */
+ if (msg == NULL) {
+ daemon_msgs = (MSGS *)malloc(sizeof(MSGS));
+ memset(daemon_msgs, 0, sizeof(MSGS));
+ for (i=1; i<=M_MAX; i++) {
+ add_msg_dest(daemon_msgs, MD_STDOUT, i, NULL, NULL);
+ add_msg_dest(daemon_msgs, MD_SYSLOG, i, NULL, NULL);
+ }
+ Dmsg1(050, "Create daemon global message resource 0x%x\n", daemon_msgs);
+ return;
+ }
+
+ /*
+ * Walk down the message resource chain duplicating it
+ * for the current Job.
+ */
+ for (d=msg->dest_chain; d; d=d->next) {
+ dnew = (DEST *)malloc(sizeof(DEST));
+ memcpy(dnew, d, sizeof(DEST));
+ dnew->next = temp_chain;
+ dnew->fd = NULL;
+ dnew->mail_filename = NULL;
+ if (d->mail_cmd) {
+ dnew->mail_cmd = bstrdup(d->mail_cmd);
+ }
+ if (d->where) {
+ dnew->where = bstrdup(d->where);
+ }
+ temp_chain = dnew;
+ }
+
+ if (jcr) {
+ jcr->jcr_msgs = (MSGS *)malloc(sizeof(MSGS));
+ memset(jcr->jcr_msgs, 0, sizeof(MSGS));
+ jcr->jcr_msgs->dest_chain = temp_chain;
+ memcpy(jcr->jcr_msgs->send_msg, msg->send_msg, sizeof(msg->send_msg));
+ } else {
+ /* If we have default values, release them now */
+ if (daemon_msgs) {
+ free_msgs_res(daemon_msgs);
+ }
+ daemon_msgs = (MSGS *)malloc(sizeof(MSGS));
+ memset(daemon_msgs, 0, sizeof(MSGS));
+ daemon_msgs->dest_chain = temp_chain;
+ memcpy(daemon_msgs->send_msg, msg->send_msg, sizeof(msg->send_msg));
+ }
+ Dmsg2(050, "Copy message resource 0x%x to 0x%x\n", msg, temp_chain);
+
+}
+
+/* Initialize so that the console (User Agent) can
+ * receive messages -- stored in a file.
+ */
+void init_console_msg(char *wd)
+{
+ int fd;
+
+ bsnprintf(con_fname, sizeof(con_fname), "%s/%s.conmsg", wd, my_name);
+ fd = open(con_fname, O_CREAT|O_RDWR|O_BINARY, 0600);
+ if (fd == -1) {
+ Emsg2(M_ERROR_TERM, 0, _("Could not open console message file %s: ERR=%s\n"),
+ con_fname, strerror(errno));
+ }
+ if (lseek(fd, 0, SEEK_END) > 0) {
+ console_msg_pending = 1;
+ }
+ close(fd);
+ con_fd = fopen(con_fname, "a+");
+ if (!con_fd) {
+ Emsg2(M_ERROR, 0, _("Could not open console message file %s: ERR=%s\n"),
+ con_fname, strerror(errno));
+ }
+ if (rwl_init(&con_lock) != 0) {
+ Emsg1(M_ERROR_TERM, 0, _("Could not get con mutex: ERR=%s\n"),
+ strerror(errno));
+ }
+}
+
+/*
+ * Called only during parsing of the config file.
+ *
+ * Add a message destination. I.e. associate a message type with
+ * a destination (code).
+ * Note, where in the case of dest_code FILE is a filename,
+ * but in the case of MAIL is a space separated list of
+ * email addresses, ...
+ */
+void add_msg_dest(MSGS *msg, int dest_code, int msg_type, char *where, char *mail_cmd)
+{
+ DEST *d;
+ /*
+ * First search the existing chain and see if we
+ * can simply add this msg_type to an existing entry.
+ */
+ for (d=msg->dest_chain; d; d=d->next) {
+ if (dest_code == d->dest_code && ((where == NULL && d->where == NULL) ||
+ (strcmp(where, d->where) == 0))) {
+ Dmsg4(200, "Add to existing d=%x msgtype=%d destcode=%d where=%s\n",
+ d, msg_type, dest_code, NPRT(where));
+ set_bit(msg_type, d->msg_types);
+ set_bit(msg_type, msg->send_msg); /* set msg_type bit in our local */
+ return;
+ }
+ }
+ /* Not found, create a new entry */
+ d = (DEST *)malloc(sizeof(DEST));
+ memset(d, 0, sizeof(DEST));
+ d->next = msg->dest_chain;
+ d->dest_code = dest_code;
+ set_bit(msg_type, d->msg_types); /* set type bit in structure */
+ set_bit(msg_type, msg->send_msg); /* set type bit in our local */
+ if (where) {
+ d->where = bstrdup(where);
+ }
+ if (mail_cmd) {
+ d->mail_cmd = bstrdup(mail_cmd);
+ }
+ Dmsg5(200, "add new d=%x msgtype=%d destcode=%d where=%s mailcmd=%s\n",
+ d, msg_type, dest_code, NPRT(where), NPRT(d->mail_cmd));
+ msg->dest_chain = d;
+}
+
+/*
+ * Called only during parsing of the config file.
+ *
+ * Remove a message destination
+ */
+void rem_msg_dest(MSGS *msg, int dest_code, int msg_type, char *where)
+{
+ DEST *d;
+
+ for (d=msg->dest_chain; d; d=d->next) {
+ Dmsg2(200, "Remove_msg_dest d=%x where=%s\n", d, NPRT(d->where));
+ if (bit_is_set(msg_type, d->msg_types) && (dest_code == d->dest_code) &&
+ ((where == NULL && d->where == NULL) ||
+ (strcmp(where, d->where) == 0))) {
+ Dmsg3(200, "Found for remove d=%x msgtype=%d destcode=%d\n",
+ d, msg_type, dest_code);
+ clear_bit(msg_type, d->msg_types);
+ Dmsg0(200, "Return rem_msg_dest\n");
+ return;
+ }
+ }
+}
+
+
+/*
+ * Create a unique filename for the mail command
+ */
+static void make_unique_mail_filename(JCR *jcr, POOLMEM **name, DEST *d)
+{
+ if (jcr) {
+ Mmsg(name, "%s/%s.mail.%s.%d", working_directory, my_name,
+ jcr->Job, (int)(long)d);
+ } else {
+ Mmsg(name, "%s/%s.mail.%s.%d", working_directory, my_name,
+ my_name, (int)(long)d);
+ }
+ Dmsg1(200, "mailname=%s\n", *name);
+}
+
+/*
+ * Open a mail pipe
+ */
+static BPIPE *open_mail_pipe(JCR *jcr, POOLMEM **cmd, DEST *d)
+{
+ BPIPE *bpipe;
+
+ if (d->mail_cmd && jcr) {
+ *cmd = edit_job_codes(jcr, *cmd, d->mail_cmd, d->where);
+ } else {
+ Mmsg(cmd, "mail -s \"Bacula Message\" %s", d->where);
+ }
+ fflush(stdout);
+
+ if (!(bpipe = open_bpipe(*cmd, 120, "rw"))) {
+ Jmsg(jcr, M_ERROR, 0, "open mail pipe %s failed: ERR=%s\n",
+ *cmd, strerror(errno));
+ }
+ return bpipe;
+}
+
+/*
+ * Close the messages for this Messages resource, which means to close
+ * any open files, and dispatch any pending email messages.
+ */
+void close_msg(JCR *jcr)
+{
+ MSGS *msgs;
+ DEST *d;
+ BPIPE *bpipe;
+ POOLMEM *cmd, *line;
+ int len, stat;
+
+ Dmsg1(050, "Close_msg jcr=0x%x\n", jcr);
+
+ if (jcr == NULL) { /* NULL -> global chain */
+ msgs = daemon_msgs;
+ } else {
+ msgs = jcr->jcr_msgs;
+ jcr->jcr_msgs = NULL;
+ }
+ if (msgs == NULL) {
+ return;
+ }
+ Dmsg1(150, "===Begin close msg resource at 0x%x\n", msgs);
+ cmd = get_pool_memory(PM_MESSAGE);
+ for (d=msgs->dest_chain; d; ) {
+ if (d->fd) {
+ switch (d->dest_code) {
+ case MD_FILE:
+ case MD_APPEND:
+ if (d->fd) {
+ fclose(d->fd); /* close open file descriptor */
+ }
+ break;
+ case MD_MAIL:
+ case MD_MAIL_ON_ERROR:
+ Dmsg0(150, "Got MD_MAIL or MD_MAIL_ON_ERROR\n");
+ if (!d->fd) {
+ break;
+ }
+ if (d->dest_code == MD_MAIL_ON_ERROR && jcr &&
+ jcr->JobStatus == JS_Terminated) {
+ goto rem_temp_file;
+ }
+
+ if (!(bpipe=open_mail_pipe(jcr, &cmd, d))) {
+ Pmsg0(000, "open mail pipe failed.\n");
+ goto rem_temp_file;
+ }
+ Dmsg0(150, "Opened mail pipe\n");
+ len = d->max_len+10;
+ line = get_memory(len);
+ rewind(d->fd);
+ while (fgets(mp_chr(line), len, d->fd)) {
+ fputs(line, bpipe->wfd);
+ }
+ if (!close_wpipe(bpipe)) { /* close write pipe sending mail */
+ Pmsg1(000, "close error: ERR=%s\n", strerror(errno));
+ }
+
+ /*
+ * Since we are closing all messages, before "recursing"
+ * make sure we are not closing the daemon messages, otherwise
+ * kaboom.
+ */
+ if (msgs != daemon_msgs) {
+ /* read what mail prog returned -- should be nothing */
+ while (fgets(mp_chr(line), len, bpipe->rfd)) {
+ Jmsg1(jcr, M_INFO, 0, _("Mail prog: %s"), line);
+ }
+ }
+
+ stat = close_bpipe(bpipe);
+ if (stat != 0 && msgs != daemon_msgs) {
+ Dmsg1(150, "Calling emsg. CMD=%s\n", cmd);
+ Jmsg3(jcr, M_ERROR, 0, _("Mail program terminated in error. stat=%d\n"
+ "CMD=%s\n"
+ "ERR=%s\n"), stat, cmd, strerror(stat));
+ }
+ free_memory(line);
+rem_temp_file:
+ /* Remove temp file */
+ fclose(d->fd);
+ unlink(mp_chr(d->mail_filename));
+ free_pool_memory(d->mail_filename);
+ d->mail_filename = NULL;
+ Dmsg0(150, "end mail or mail on error\n");
+ break;
+ default:
+ break;
+ }
+ d->fd = NULL;
+ }
+ d = d->next; /* point to next buffer */
+ }
+ free_pool_memory(cmd);
+ Dmsg0(150, "Done walking message chain.\n");
+ if (jcr) {
+ free_msgs_res(msgs);
+ msgs = NULL;
+ }
+ Dmsg0(150, "===End close msg resource\n");
+}
+
+/*
+ * Free memory associated with Messages resource
+ */
+void free_msgs_res(MSGS *msgs)
+{
+ DEST *d, *old;
+
+ /* Walk down the message chain releasing allocated buffers */
+ for (d=msgs->dest_chain; d; ) {
+ if (d->where) {
+ free(d->where);
+ }
+ if (d->mail_cmd) {
+ free(d->mail_cmd);
+ }
+ old = d; /* save pointer to release */
+ d = d->next; /* point to next buffer */
+ free(old); /* free the destination item */
+ }
+ msgs->dest_chain = NULL;
+ free(msgs); /* free the head */
+}
+
+
+/*
+ * Terminate the message handler for good.
+ * Release the global destination chain.
+ *
+ * Also, clean up a few other items (cons, exepath). Note,
+ * these really should be done elsewhere.
+ */
+void term_msg()
+{
+ Dmsg0(100, "Enter term_msg\n");
+ close_msg(NULL); /* close global chain */
+ free_msgs_res(daemon_msgs); /* free the resources */
+ daemon_msgs = NULL;
+ if (con_fd) {
+ fflush(con_fd);
+ fclose(con_fd);
+ con_fd = NULL;
+ }
+ if (exepath) {
+ free(exepath);
+ exepath = NULL;
+ }
+ if (exename) {
+ free(exename);
+ exename = NULL;
+ }
+ if (trace_fd) {
+ fclose(trace_fd);
+ trace_fd = NULL;
+ }
+ term_last_jobs_list();
+}
+
+
+
+/*
+ * Handle sending the message to the appropriate place
+ */
+void dispatch_message(JCR *jcr, int type, int level, char *msg)
+{
+ DEST *d;
+ char dt[MAX_TIME_LENGTH];
+ POOLMEM *mcmd;
+ int len;
+ MSGS *msgs;
+ BPIPE *bpipe;
+
+ Dmsg2(800, "Enter dispatch_msg type=%d msg=%s\n", type, msg);
+
+ if (type == M_ABORT || type == M_ERROR_TERM) {
+ fputs(msg, stdout); /* print this here to INSURE that it is printed */
+ fflush(stdout);
+#if defined(HAVE_CYGWIN) || defined(HAVE_WIN32)
+ MessageBox(NULL, msg, "Bacula", MB_OK);
+#endif
+ }
+
+ /* Now figure out where to send the message */
+ msgs = NULL;
+ if (jcr) {
+ msgs = jcr->jcr_msgs;
+ }
+ if (msgs == NULL) {
+ msgs = daemon_msgs;
+ }
+ for (d=msgs->dest_chain; d; d=d->next) {
+ if (bit_is_set(type, d->msg_types)) {
+ switch (d->dest_code) {
+ case MD_CONSOLE:
+ Dmsg1(800, "CONSOLE for following msg: %s", msg);
+ if (!con_fd) {
+ con_fd = fopen(con_fname, "a+");
+ Dmsg0(800, "Console file not open.\n");
+ }
+ if (con_fd) {
+ Pw(con_lock); /* get write lock on console message file */
+ errno = 0;
+ bstrftime(dt, sizeof(dt), time(NULL));
+ len = strlen(dt);
+ dt[len++] = ' ';
+ fwrite(dt, len, 1, con_fd);
+ len = strlen(msg);
+ if (len > 0) {
+ fwrite(msg, len, 1, con_fd);
+ if (msg[len-1] != '\n') {
+ fwrite("\n", 2, 1, con_fd);
+ }
+ } else {
+ fwrite("\n", 2, 1, con_fd);
+ }
+ fflush(con_fd);
+ console_msg_pending = TRUE;
+ Vw(con_lock);
+ }
+ break;
+ case MD_SYSLOG:
+ Dmsg1(800, "SYSLOG for collowing msg: %s\n", msg);
+ /*
+ * We really should do an openlog() here.
+ */
+ syslog(LOG_DAEMON|LOG_ERR, "%s", msg);
+ break;
+ case MD_OPERATOR:
+ Dmsg1(800, "OPERATOR for collowing msg: %s\n", msg);
+ mcmd = get_pool_memory(PM_MESSAGE);
+ if ((bpipe=open_mail_pipe(jcr, &mcmd, d))) {
+ int stat;
+ fputs(msg, bpipe->wfd);
+ /* Messages to the operator go one at a time */
+ stat = close_bpipe(bpipe);
+ if (stat != 0) {
+ Jmsg2(jcr, M_ERROR, 0, _("Operator mail program terminated in error.\n"
+ "CMD=%s\n"
+ "ERR=%s\n"), mcmd, strerror(stat));
+ }
+ }
+ free_pool_memory(mcmd);
+ break;
+ case MD_MAIL:
+ case MD_MAIL_ON_ERROR:
+ Dmsg1(800, "MAIL for following msg: %s", msg);
+ if (!d->fd) {
+ POOLMEM *name = get_pool_memory(PM_MESSAGE);
+ make_unique_mail_filename(jcr, &mp_chr(name), d);
+ d->fd = fopen(mp_chr(name), "w+");
+ if (!d->fd) {
+ d->fd = stdout;
+ Jmsg2(jcr, M_ERROR, 0, "fopen %s failed: ERR=%s\n", name, strerror(errno));
+ d->fd = NULL;
+ free_pool_memory(name);
+ break;
+ }
+ d->mail_filename = name;
+ }
+ len = strlen(msg);
+ if (len > d->max_len) {
+ d->max_len = len; /* keep max line length */
+ }
+ fputs(msg, d->fd);
+ break;
+ case MD_FILE:
+ Dmsg1(800, "FILE for following msg: %s", msg);
+ if (!d->fd) {
+ d->fd = fopen(d->where, "w+");
+ if (!d->fd) {
+ d->fd = stdout;
+ Jmsg2(jcr, M_ERROR, 0, "fopen %s failed: ERR=%s\n", d->where, strerror(errno));
+ d->fd = NULL;
+ break;
+ }
+ }
+ fputs(msg, d->fd);
+ break;
+ case MD_APPEND:
+ Dmsg1(800, "APPEND for following msg: %s", msg);
+ if (!d->fd) {
+ d->fd = fopen(d->where, "a");
+ if (!d->fd) {
+ d->fd = stdout;
+ Jmsg2(jcr, M_ERROR, 0, "fopen %s failed: ERR=%s\n", d->where, strerror(errno));
+ d->fd = NULL;
+ break;
+ }
+ }
+ fputs(msg, d->fd);
+ break;
+ case MD_DIRECTOR:
+ Dmsg1(800, "DIRECTOR for following msg: %s", msg);
+ if (jcr && jcr->dir_bsock && !jcr->dir_bsock->errors) {
+ bnet_fsend(jcr->dir_bsock, "Jmsg Job=%s type=%d level=%d %s",
+ jcr->Job, type, level, msg);
+ }
+ break;
+ case MD_STDOUT:
+ Dmsg1(800, "STDOUT for following msg: %s", msg);
+ if (type != M_ABORT && type != M_ERROR_TERM) { /* already printed */
+ fputs(msg, stdout);
+ }
+ break;
+ case MD_STDERR:
+ Dmsg1(800, "STDERR for following msg: %s", msg);
+ fputs(msg, stderr);
+ break;
+ default:
+ break;
+ }
+ }
+ }
+}
+
+
+/*********************************************************************
+ *
+ * This subroutine prints a debug message if the level number
+ * is less than or equal the debug_level. File and line numbers
+ * are included for more detail if desired, but not currently
+ * printed.
+ *
+ * If the level is negative, the details of file and line number
+ * are not printed.
+ */
+void
+d_msg(const char *file, int line, int level, const char *fmt,...)
+{
+ char buf[5000];
+ int len;
+ va_list arg_ptr;
+ int details = TRUE;
+
+ if (level < 0) {
+ details = FALSE;
+ level = -level;
+ }
+
+ if (level <= debug_level) {
+#ifdef FULL_LOCATION
+ if (details) {
+ /* visual studio passes the whole path to the file as well
+ * which makes for very long lines
+ */
+ char *f = strrchr(file, '\\');
+ if (f) file = f + 1;
+ len = bsnprintf(buf, sizeof(buf), "%s: %s:%d ", my_name, file, line);
+ } else {
+ len = 0;
+ }
+#else
+ len = 0;
+#endif
+ va_start(arg_ptr, fmt);
+ bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
+ va_end(arg_ptr);
+
+ /*
+ * Used the "trace on" command in the console to turn on
+ * output to the trace file. "trace off" will close the file.
+ */
+ if (trace) {
+ if (!trace_fd) {
+ bsnprintf(buf, sizeof(buf), "%s/bacula.trace", working_directory ? working_directory : ".");
+ trace_fd = fopen(buf, "a+");
+ }
+ if (trace_fd) {
+ fputs(buf, trace_fd);
+ fflush(trace_fd);
+ }
+ } else { /* not tracing */
+ fputs(buf, stdout);
+ }
+ }
+}
+
+/*
+ * Set trace flag on/off. If argument is negative, there is no change
+ */
+void set_trace(int trace_flag)
+{
+ if (trace_flag < 0) {
+ return;
+ } else if (trace_flag > 0) {
+ trace = true;
+ } else {
+ trace = false;
+ }
+ if (!trace && trace_fd) {
+ FILE *ltrace_fd = trace_fd;
+ trace_fd = NULL;
+ bmicrosleep(0, 100000); /* yield to prevent seg faults */
+ fclose(ltrace_fd);
+ }
+}
+
+/*********************************************************************
+ *
+ * This subroutine prints a message regardless of the debug level
+ *
+ * If the level is negative, the details of file and line number
+ * are not printed.
+ */
+void
+p_msg(const char *file, int line, int level, const char *fmt,...)
+{
+ char buf[5000];
+ int len;
+ va_list arg_ptr;
+
+#ifdef FULL_LOCATION
+ if (level >= 0) {
+ len = bsnprintf(buf, sizeof(buf), "%s: %s:%d ", my_name, file, line);
+ } else {
+ len = 0;
+ }
+#else
+ len = 0;
+#endif
+ va_start(arg_ptr, fmt);
+ bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
+ va_end(arg_ptr);
+ fputs(buf, stdout);
+}
+
+
+/*********************************************************************
+ *
+ * subroutine writes a debug message to the trace file if the level number
+ * is less than or equal the debug_level. File and line numbers
+ * are included for more detail if desired, but not currently
+ * printed.
+ *
+ * If the level is negative, the details of file and line number
+ * are not printed.
+ */
+void
+t_msg(const char *file, int line, int level, const char *fmt,...)
+{
+ char buf[5000];
+ int len;
+ va_list arg_ptr;
+ int details = TRUE;
+
+ if (level < 0) {
+ details = FALSE;
+ level = -level;
+ }
+
+ if (level <= debug_level) {
+ if (!trace_fd) {
+ bsnprintf(buf, sizeof(buf), "%s/bacula.trace", working_directory);
+ trace_fd = fopen(buf, "a+");
+ }
+
+#ifdef FULL_LOCATION
+ if (details) {
+ len = bsnprintf(buf, sizeof(buf), "%s: %s:%d ", my_name, file, line);
+ } else {
+ len = 0;
+ }
+#else
+ len = 0;
+#endif
+ va_start(arg_ptr, fmt);
+ bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
+ va_end(arg_ptr);
+ if (trace_fd != NULL) {
+ fputs(buf, trace_fd);
+ fflush(trace_fd);
+ }
+ }
+}
+
+
+
+/* *********************************************************
+ *
+ * print an error message
+ *
+ */
+void
+e_msg(const char *file, int line, int type, int level, const char *fmt,...)
+{
+ char buf[5000];
+ va_list arg_ptr;
+ int len;
+
+ /*
+ * Check if we have a message destination defined.
+ * We always report M_ABORT and M_ERROR_TERM
+ */
+ if (!daemon_msgs || ((type != M_ABORT && type != M_ERROR_TERM) &&
+ !bit_is_set(type, daemon_msgs->send_msg))) {
+ return; /* no destination */
+ }
+ switch (type) {
+ case M_ABORT:
+ len = bsnprintf(buf, sizeof(buf), "%s: ABORTING due to ERROR in %s:%d\n",
+ my_name, file, line);
+ break;
+ case M_ERROR_TERM:
+ len = bsnprintf(buf, sizeof(buf), "%s: ERROR TERMINATION at %s:%d\n",
+ my_name, file, line);
+ break;
+ case M_FATAL:
+ if (level == -1) /* skip details */
+ len = bsnprintf(buf, sizeof(buf), "%s: Fatal Error because: ", my_name);
+ else
+ len = bsnprintf(buf, sizeof(buf), "%s: Fatal Error at %s:%d because:\n", my_name, file, line);
+ break;
+ case M_ERROR:
+ if (level == -1) /* skip details */
+ len = bsnprintf(buf, sizeof(buf), "%s: ERROR: ", my_name);
+ else
+ len = bsnprintf(buf, sizeof(buf), "%s: ERROR in %s:%d ", my_name, file, line);
+ break;
+ case M_WARNING:
+ len = bsnprintf(buf, sizeof(buf), "%s: Warning: ", my_name);
+ break;
+ case M_SECURITY:
+ len = bsnprintf(buf, sizeof(buf), "%s: Security violation: ", my_name);
+ break;
+ default:
+ len = bsnprintf(buf, sizeof(buf), "%s: ", my_name);
+ break;
+ }
+
+ va_start(arg_ptr, fmt);
+ bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
+ va_end(arg_ptr);
+
+ dispatch_message(NULL, type, level, buf);
+
+ if (type == M_ABORT) {
+ char *p = 0;
+ p[0] = 0; /* generate segmentation violation */
+ }
+ if (type == M_ERROR_TERM) {
+ exit(1);
+ }
+}
+
+/* *********************************************************
+ *
+ * Generate a Job message
+ *
+ */
+void
+Jmsg(JCR *jcr, int type, int level, const char *fmt,...)
+{
+ char rbuf[5000];
+ va_list arg_ptr;
+ int len;
+ MSGS *msgs;
+ const char *job;
+
+
+ Dmsg1(800, "Enter Jmsg type=%d\n", type);
+
+ /* Special case for the console, which has a dir_bsock and JobId==0,
+ * in that case, we send the message directly back to the
+ * dir_bsock.
+ */
+ if (jcr && jcr->JobId == 0 && jcr->dir_bsock) {
+ BSOCK *dir = jcr->dir_bsock;
+ va_start(arg_ptr, fmt);
+ dir->msglen = bvsnprintf(mp_chr(dir->msg), sizeof_pool_memory(dir->msg),
+ fmt, arg_ptr);
+ va_end(arg_ptr);
+ bnet_send(jcr->dir_bsock);
+ return;
+ }
+
+ msgs = NULL;
+ job = NULL;
+ if (jcr) {
+ msgs = jcr->jcr_msgs;
+ job = jcr->Job;
+ }
+ if (!msgs) {
+ msgs = daemon_msgs; /* if no jcr, we use daemon handler */
+ }
+ if (!job) {
+ job = ""; /* Set null job name if none */
+ }
+
+ /*
+ * Check if we have a message destination defined.
+ * We always report M_ABORT and M_ERROR_TERM
+ */
+ if (msgs && (type != M_ABORT && type != M_ERROR_TERM) &&
+ !bit_is_set(type, msgs->send_msg)) {
+ return; /* no destination */
+ }
+ switch (type) {
+ case M_ABORT:
+ len = bsnprintf(rbuf, sizeof(rbuf), "%s ABORTING due to ERROR\n", my_name);
+ break;
+ case M_ERROR_TERM:
+ len = bsnprintf(rbuf, sizeof(rbuf), "%s ERROR TERMINATION\n", my_name);
+ break;
+ case M_FATAL:
+ len = bsnprintf(rbuf, sizeof(rbuf), "%s: %s Fatal error: ", my_name, job);
+ if (jcr) {
+ set_jcr_job_status(jcr, JS_FatalError);
+ }
+ break;
+ case M_ERROR:
+ len = bsnprintf(rbuf, sizeof(rbuf), "%s: %s Error: ", my_name, job);
+ if (jcr) {
+ jcr->Errors++;
+ }
+ break;
+ case M_WARNING:
+ len = bsnprintf(rbuf, sizeof(rbuf), "%s: %s Warning: ", my_name, job);
+ break;
+ case M_SECURITY:
+ len = bsnprintf(rbuf, sizeof(rbuf), "%s: %s Security violation: ", my_name, job);
+ break;
+ default:
+ len = bsnprintf(rbuf, sizeof(rbuf), "%s: ", my_name);
+ break;
+ }
+
+ va_start(arg_ptr, fmt);
+ bvsnprintf(rbuf+len, sizeof(rbuf)-len, fmt, arg_ptr);
+ va_end(arg_ptr);
+
+ dispatch_message(jcr, type, level, rbuf);
+
+ if (type == M_ABORT){
+ char *p = 0;
+ p[0] = 0; /* generate segmentation violation */
+ }
+ if (type == M_ERROR_TERM) {
+ exit(1);
+ }
+}
+
+/*
+ * If we come here, prefix the message with the file:line-number,
+ * then pass it on to the normal Jmsg routine.
+ */
+void j_msg(const char *file, int line, JCR *jcr, int type, int level, const char *fmt,...)
+{
+ va_list arg_ptr;
+ int i, len, maxlen;
+ POOLMEM *pool_buf;
+
+ pool_buf = get_pool_memory(PM_EMSG);
+ i = Mmsg(&pool_buf, "%s:%d ", file, line);
+
+ for (;;) {
+ maxlen = sizeof_pool_memory(pool_buf) - i - 1;
+ va_start(arg_ptr, fmt);
+ len = bvsnprintf(pool_buf+i, maxlen, fmt, arg_ptr);
+ va_end(arg_ptr);
+ if (len < 0 || len >= maxlen) {
+ pool_buf = realloc_pool_memory(pool_buf, maxlen + i + maxlen/2);
+ continue;
+ }
+ break;
+ }
+
+ Jmsg(jcr, type, level, "%s", pool_buf);
+ free_memory(pool_buf);
+}
+
+
+/*
+ * Edit a message into a Pool memory buffer, with file:lineno
+ */
+int m_msg(const char *file, int line, POOLMEM **pool_buf, const char *fmt, ...)
+{
+ va_list arg_ptr;
+ int i, len, maxlen;
+
+ i = sprintf(mp_chr(*pool_buf), "%s:%d ", file, line);
+
+ for (;;) {
+ maxlen = sizeof_pool_memory(*pool_buf) - i - 1;
+ va_start(arg_ptr, fmt);
+ len = bvsnprintf(*pool_buf+i, maxlen, fmt, arg_ptr);
+ va_end(arg_ptr);
+ if (len < 0 || len >= maxlen) {
+ *pool_buf = realloc_pool_memory(*pool_buf, maxlen + i + maxlen/2);
+ continue;
+ }
+ break;
+ }
+ return len;
+}
+
+/*
+ * Edit a message into a Pool Memory buffer NO file:lineno
+ * Returns: string length of what was edited.
+ */
+int Mmsg(POOLMEM **pool_buf, const char *fmt, ...)
+{
+ va_list arg_ptr;
+ int len, maxlen;
+
+ for (;;) {
+ maxlen = sizeof_pool_memory(*pool_buf) - 1;
+ va_start(arg_ptr, fmt);
+ len = bvsnprintf(*pool_buf, maxlen, fmt, arg_ptr);
+ va_end(arg_ptr);
+ if (len < 0 || len >= maxlen) {
+ *pool_buf = realloc_pool_memory(*pool_buf, maxlen + maxlen/2);
+ continue;
+ }
+ break;
+ }
+ return len;
+}
+
+static pthread_mutex_t msg_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/*
+ * We queue messages rather than print them directly. This
+ * is generally used in low level routines (msg handler, bnet)
+ * to prevent recursion (i.e. if you are in the middle of
+ * sending a message, it is a bit messy to recursively call
+ * yourself when the bnet packet is not reentrant).
+ */
+void Qmsg(JCR *jcr, int type, int level, const char *fmt,...)
+{
+ va_list arg_ptr;
+ int len, maxlen;
+ POOLMEM *pool_buf;
+ MQUEUE_ITEM *item;
+
+ pool_buf = get_pool_memory(PM_EMSG);
+
+ for (;;) {
+ maxlen = sizeof_pool_memory(pool_buf) - 1;
+ va_start(arg_ptr, fmt);
+ len = bvsnprintf(pool_buf, maxlen, fmt, arg_ptr);
+ va_end(arg_ptr);
+ if (len < 0 || len >= maxlen) {
+ pool_buf = realloc_pool_memory(pool_buf, maxlen + maxlen/2);
+ continue;
+ }
+ break;
+ }
+ item = (MQUEUE_ITEM *)malloc(sizeof(MQUEUE_ITEM) + strlen(pool_buf) + 1);
+ item->type = type;
+ item->level = level;
+ strcpy(item->msg, pool_buf);
+ P(msg_queue_mutex);
+ /* If no jcr or dequeuing send to daemon to avoid recursion */
+ if (!jcr || jcr->dequeuing) {
+ /* jcr==NULL => daemon message, safe to send now */
+ Jmsg(NULL, item->type, item->level, "%s", item->msg);
+ free(item);
+ } else {
+ /* Queue message for later sending */
+ jcr->msg_queue->append(item);
+ }
+ V(msg_queue_mutex);
+ free_memory(pool_buf);
+}
+
+/*
+ * Dequeue messages
+ */
+void dequeue_messages(JCR *jcr)
+{
+ MQUEUE_ITEM *item;
+ P(msg_queue_mutex);
+ jcr->dequeuing = true;
+ foreach_dlist(item, jcr->msg_queue) {
+ Jmsg(jcr, item->type, item->level, "%s", item->msg);
+ }
+ jcr->msg_queue->destroy();
+ jcr->dequeuing = false;
+ V(msg_queue_mutex);
+}
+
+
+/*
+ * If we come here, prefix the message with the file:line-number,
+ * then pass it on to the normal Qmsg routine.
+ */
+void q_msg(const char *file, int line, JCR *jcr, int type, int level, const char *fmt,...)
+{
+ va_list arg_ptr;
+ int i, len, maxlen;
+ POOLMEM *pool_buf;
+
+ pool_buf = get_pool_memory(PM_EMSG);
+ i = Mmsg(&pool_buf, "%s:%d ", file, line);
+
+ for (;;) {
+ maxlen = sizeof_pool_memory(pool_buf) - i - 1;
+ va_start(arg_ptr, fmt);
+ len = bvsnprintf(pool_buf+i, maxlen, fmt, arg_ptr);
+ va_end(arg_ptr);
+ if (len < 0 || len >= maxlen) {
+ pool_buf = realloc_pool_memory(pool_buf, maxlen + i + maxlen/2);
+ continue;
+ }
+ break;
+ }
+
+ Qmsg(jcr, type, level, "%s", pool_buf);
+ free_memory(pool_buf);
+}
--- /dev/null
+/*
+ * Master Configuration routines.
+ *
+ * This file contains the common parts of the Bacula
+ * configuration routines.
+ *
+ * Note, the configuration file parser consists of three parts
+ *
+ * 1. The generic lexical scanner in lib/lex.c and lib/lex.h
+ *
+ * 2. The generic config scanner in lib/parse_conf.c and
+ * lib/parse_conf.h.
+ * These files contain the parser code, some utility
+ * routines, and the common store routines (name, int,
+ * string).
+ *
+ * 3. The daemon specific file, which contains the Resource
+ * definitions as well as any specific store routines
+ * for the resource records.
+ *
+ * N.B. This is a two pass parser, so if you malloc() a string
+ * in a "store" routine, you must ensure to do it during
+ * only one of the two passes, or to free it between.
+ * Also, note that the resource record is malloced and
+ * saved in save_resource() during pass 1. Anything that
+ * you want saved after pass two (e.g. resource pointers)
+ * must explicitly be done in save_resource. Take a look
+ * at the Job resource in src/dird/dird_conf.c to see how
+ * it is done.
+ *
+ * Kern Sibbald, January MM
+ *
+ * Version $Id$
+ */
+
+/*
+ Copyright (C) 2000-2003 Kern Sibbald and John Walker
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of
+ the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public
+ License along with this program; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA.
+
+ */
+
+
+#include "bacula.h"
+
+extern int debug_level;
+
+/* Each daemon has a slightly different set of
+ * resources, so it will define the following
+ * global values.
+ */
+extern int r_first;
+extern int r_last;
+extern RES_TABLE resources[];
+#ifdef HAVE_WIN32
+// work around visual studio name manling preventing external linkage since res_all
+// is declared as a different type when instantiated.
+extern "C" CURES res_all;
+extern "C" int res_all_size;
+#else
+extern CURES res_all;
+extern int res_all_size;
+#endif
+
+
+static brwlock_t res_lock; /* resource lock */
+static int res_locked = 0; /* set when resource chains locked -- for debug */
+
+/* Forward referenced subroutines */
+static void scan_types(LEX *lc, MSGS *msg, int dest, char *where, char *cmd);
+
+
+/* Common Resource definitions */
+
+/* Message resource directives
+ * name handler value code flags default_value
+ */
+RES_ITEM msgs_items[] = {
+ {"name", store_name, ITEM(res_msgs.hdr.name), 0, 0, 0},
+ {"description", store_str, ITEM(res_msgs.hdr.desc), 0, 0, 0},
+ {"mailcommand", store_str, ITEM(res_msgs.mail_cmd), 0, 0, 0},
+ {"operatorcommand", store_str, ITEM(res_msgs.operator_cmd), 0, 0, 0},
+ {"syslog", store_msgs, ITEM(res_msgs), MD_SYSLOG, 0, 0},
+ {"mail", store_msgs, ITEM(res_msgs), MD_MAIL, 0, 0},
+ {"mailonerror", store_msgs, ITEM(res_msgs), MD_MAIL_ON_ERROR, 0, 0},
+ {"file", store_msgs, ITEM(res_msgs), MD_FILE, 0, 0},
+ {"append", store_msgs, ITEM(res_msgs), MD_APPEND, 0, 0},
+ {"stdout", store_msgs, ITEM(res_msgs), MD_STDOUT, 0, 0},
+ {"stderr", store_msgs, ITEM(res_msgs), MD_STDERR, 0, 0},
+ {"director", store_msgs, ITEM(res_msgs), MD_DIRECTOR, 0, 0},
+ {"console", store_msgs, ITEM(res_msgs), MD_CONSOLE, 0, 0},
+ {"operator", store_msgs, ITEM(res_msgs), MD_OPERATOR, 0, 0},
+ {NULL, NULL, NULL, 0}
+};
+
+struct s_mtypes {
+ const char *name;
+ int token;
+};
+/* Various message types */
+static struct s_mtypes msg_types[] = {
+ {"debug", M_DEBUG},
+ {"abort", M_ABORT},
+ {"fatal", M_FATAL},
+ {"error", M_ERROR},
+ {"warning", M_WARNING},
+ {"info", M_INFO},
+ {"saved", M_SAVED},
+ {"notsaved", M_NOTSAVED},
+ {"skipped", M_SKIPPED},
+ {"mount", M_MOUNT},
+ {"terminate", M_TERM},
+ {"restored", M_RESTORED},
+ {"all", M_MAX+1},
+ {NULL, 0}
+};
+
+
+/* Simply print a message */
+static void prtmsg(void *sock, char *fmt, ...)
+{
+ va_list arg_ptr;
+
+ va_start(arg_ptr, fmt);
+ vfprintf(stdout, fmt, arg_ptr);
+ va_end(arg_ptr);
+}
+
+const char *res_to_str(int rcode)
+{
+ if (rcode < r_first || rcode > r_last) {
+ return _("***UNKNOWN***");
+ } else {
+ return resources[rcode-r_first].name;
+ }
+}
+
+
+/*
+ * Initialize the static structure to zeros, then
+ * apply all the default values.
+ */
+void init_resource(int type, RES_ITEM *items)
+{
+ int i;
+ int rindex = type - r_first;
+ static bool first = true;
+ int errstat;
+
+ if (first && (errstat=rwl_init(&res_lock)) != 0) {
+ Emsg1(M_ABORT, 0, _("Unable to initialize resource lock. ERR=%s\n"),
+ strerror(errstat));
+ }
+ first = false;
+
+ memset(&res_all, 0, res_all_size);
+ res_all.hdr.rcode = type;
+ res_all.hdr.refcnt = 1;
+
+ for (i=0; items[i].name; i++) {
+ Dmsg3(300, "Item=%s def=%s defval=%d\n", items[i].name,
+ (items[i].flags & ITEM_DEFAULT) ? "yes" : "no",
+ items[i].default_value);
+ if (items[i].flags & ITEM_DEFAULT && items[i].default_value != 0) {
+ if (items[i].handler == store_yesno) {
+ *(int *)(items[i].value) |= items[i].code;
+ } else if (items[i].handler == store_pint ||
+ items[i].handler == store_int) {
+ *(int *)(items[i].value) = items[i].default_value;
+ } else if (items[i].handler == store_int64) {
+ *(int64_t *)(items[i].value) = items[i].default_value;
+ } else if (items[i].handler == store_size) {
+ *(uint64_t *)(items[i].value) = (uint64_t)items[i].default_value;
+ } else if (items[i].handler == store_time) {
+ *(utime_t *)(items[i].value) = (utime_t)items[i].default_value;
+ }
+ }
+ /* If this triggers, take a look at lib/parse_conf.h */
+ if (i >= MAX_RES_ITEMS) {
+ Emsg1(M_ERROR_TERM, 0, _("Too many items in %s resource\n"), resources[rindex]);
+ }
+ }
+}
+
+
+/* Store Messages Destination information */
+void store_msgs(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ int token;
+ char *cmd;
+ POOLMEM *dest;
+ int dest_len;
+
+ Dmsg2(300, "store_msgs pass=%d code=%d\n", pass, item->code);
+ if (pass == 1) {
+ switch (item->code) {
+ case MD_STDOUT:
+ case MD_STDERR:
+ case MD_SYSLOG: /* syslog */
+ case MD_CONSOLE:
+ scan_types(lc, (MSGS *)(item->value), item->code, NULL, NULL);
+ break;
+ case MD_OPERATOR: /* send to operator */
+ case MD_DIRECTOR: /* send to Director */
+ case MD_MAIL: /* mail */
+ case MD_MAIL_ON_ERROR: /* mail if Job errors */
+ if (item->code == MD_OPERATOR) {
+ cmd = res_all.res_msgs.operator_cmd;
+ } else {
+ cmd = res_all.res_msgs.mail_cmd;
+ }
+ dest = get_pool_memory(PM_MESSAGE);
+ dest[0] = 0;
+ dest_len = 0;
+ /* Pick up comma separated list of destinations */
+ for ( ;; ) {
+ token = lex_get_token(lc, T_NAME); /* scan destination */
+ dest = check_pool_memory_size(dest, dest_len + lc->str_len + 2);
+ if (dest[0] != 0) {
+ pm_strcat(&dest, " "); /* separate multiple destinations with space */
+ dest_len++;
+ }
+ pm_strcat(&dest, lc->str);
+ dest_len += lc->str_len;
+ Dmsg2(100, "store_msgs newdest=%s: dest=%s:\n", lc->str, NPRT(dest));
+ token = lex_get_token(lc, T_ALL);
+ if (token == T_COMMA) {
+ continue; /* get another destination */
+ }
+ if (token != T_EQUALS) {
+ scan_err1(lc, _("expected an =, got: %s"), lc->str);
+ }
+ break;
+ }
+ Dmsg1(300, "mail_cmd=%s\n", NPRT(cmd));
+ scan_types(lc, (MSGS *)(item->value), item->code, dest, cmd);
+ free_pool_memory(dest);
+ Dmsg0(300, "done with dest codes\n");
+ break;
+ case MD_FILE: /* file */
+ case MD_APPEND: /* append */
+ dest = get_pool_memory(PM_MESSAGE);
+ /* Pick up a single destination */
+ token = lex_get_token(lc, T_NAME); /* scan destination */
+ pm_strcpy(&dest, lc->str);
+ dest_len = lc->str_len;
+ token = lex_get_token(lc, T_ALL);
+ Dmsg1(300, "store_msgs dest=%s:\n", NPRT(dest));
+ if (token != T_EQUALS) {
+ scan_err1(lc, _("expected an =, got: %s"), lc->str);
+ }
+ scan_types(lc, (MSGS *)(item->value), item->code, dest, NULL);
+ free_pool_memory(dest);
+ Dmsg0(300, "done with dest codes\n");
+ break;
+
+ default:
+ scan_err1(lc, _("Unknown item code: %d\n"), item->code);
+ break;
+ }
+ }
+ scan_to_eol(lc);
+ set_bit(index, res_all.hdr.item_present);
+ Dmsg0(300, "Done store_msgs\n");
+}
+
+/*
+ * Scan for message types and add them to the message
+ * destination. The basic job here is to connect message types
+ * (WARNING, ERROR, FATAL, INFO, ...) with an appropriate
+ * destination (MAIL, FILE, OPERATOR, ...)
+ */
+static void scan_types(LEX *lc, MSGS *msg, int dest_code, char *where, char *cmd)
+{
+ int i, found, quit, is_not;
+ int msg_type = 0;
+ char *str;
+
+ for (quit=0; !quit;) {
+ lex_get_token(lc, T_NAME); /* expect at least one type */
+ found = FALSE;
+ if (lc->str[0] == '!') {
+ is_not = TRUE;
+ str = &lc->str[1];
+ } else {
+ is_not = FALSE;
+ str = &lc->str[0];
+ }
+ for (i=0; msg_types[i].name; i++) {
+ if (strcasecmp(str, msg_types[i].name) == 0) {
+ msg_type = msg_types[i].token;
+ found = TRUE;
+ break;
+ }
+ }
+ if (!found) {
+ scan_err1(lc, _("message type: %s not found"), str);
+ /* NOT REACHED */
+ }
+
+ if (msg_type == M_MAX+1) { /* all? */
+ for (i=1; i<=M_MAX; i++) { /* yes set all types */
+ add_msg_dest(msg, dest_code, i, where, cmd);
+ }
+ } else {
+ if (is_not) {
+ rem_msg_dest(msg, dest_code, msg_type, where);
+ } else {
+ add_msg_dest(msg, dest_code, msg_type, where, cmd);
+ }
+ }
+ if (lc->ch != ',') {
+ break;
+ }
+ Dmsg0(300, "call lex_get_token() to eat comma\n");
+ lex_get_token(lc, T_ALL); /* eat comma */
+ }
+ Dmsg0(300, "Done scan_types()\n");
+}
+
+
+/*
+ * This routine is ONLY for resource names
+ * Store a name at specified address.
+ */
+void store_name(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ POOLMEM *msg = get_pool_memory(PM_EMSG);
+ lex_get_token(lc, T_NAME);
+ if (!is_name_valid(lc->str, &msg)) {
+ scan_err1(lc, "%s\n", msg);
+ }
+ free_pool_memory(msg);
+ /* Store the name both pass 1 and pass 2 */
+ if (*(item->value)) {
+ scan_err2(lc, _("Attempt to redefine name \"%s\" to \"%s\"."),
+ *(item->value), lc->str);
+ }
+ *(item->value) = bstrdup(lc->str);
+ scan_to_eol(lc);
+ set_bit(index, res_all.hdr.item_present);
+}
+
+
+/*
+ * Store a name string at specified address
+ * A name string is limited to MAX_RES_NAME_LENGTH
+ */
+void store_strname(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ lex_get_token(lc, T_NAME);
+ /* Store the name */
+ if (pass == 1) {
+ *(item->value) = bstrdup(lc->str);
+ }
+ scan_to_eol(lc);
+ set_bit(index, res_all.hdr.item_present);
+}
+
+/* Store a string at specified address */
+void store_str(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ lex_get_token(lc, T_STRING);
+ if (pass == 1) {
+ *(item->value) = bstrdup(lc->str);
+ }
+ scan_to_eol(lc);
+ set_bit(index, res_all.hdr.item_present);
+}
+
+/*
+ * Store a directory name at specified address. Note, we do
+ * shell expansion except if the string begins with a vertical
+ * bar (i.e. it will likely be passed to the shell later).
+ */
+void store_dir(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ lex_get_token(lc, T_STRING);
+ if (pass == 1) {
+ if (lc->str[0] != '|') {
+ do_shell_expansion(lc->str, sizeof(lc->str));
+ }
+ *(item->value) = bstrdup(lc->str);
+ }
+ scan_to_eol(lc);
+ set_bit(index, res_all.hdr.item_present);
+}
+
+
+/* Store a password specified address in MD5 coding */
+void store_password(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ unsigned int i, j;
+ struct MD5Context md5c;
+ unsigned char signature[16];
+ char sig[100];
+
+
+ lex_get_token(lc, T_STRING);
+ if (pass == 1) {
+ MD5Init(&md5c);
+ MD5Update(&md5c, (unsigned char *) (lc->str), lc->str_len);
+ MD5Final(signature, &md5c);
+ for (i = j = 0; i < sizeof(signature); i++) {
+ sprintf(&sig[j], "%02x", signature[i]);
+ j += 2;
+ }
+ *(item->value) = bstrdup(sig);
+ }
+ scan_to_eol(lc);
+ set_bit(index, res_all.hdr.item_present);
+}
+
+
+/* Store a resource at specified address.
+ * If we are in pass 2, do a lookup of the
+ * resource.
+ */
+void store_res(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ RES *res;
+
+ lex_get_token(lc, T_NAME);
+ if (pass == 2) {
+ res = GetResWithName(item->code, lc->str);
+ if (res == NULL) {
+ scan_err3(lc, _("Could not find config Resource %s referenced on line %d : %s\n"),
+ lc->str, lc->line_no, lc->line);
+ }
+ *(item->value) = (char *)res;
+ }
+ scan_to_eol(lc);
+ set_bit(index, res_all.hdr.item_present);
+}
+
+/*
+ * Store default values for Resource from xxxDefs
+ * If we are in pass 2, do a lookup of the
+ * resource and store everything not explicitly set
+ * in main resource.
+ *
+ * Note, here item points to the main resource (e.g. Job, not
+ * the jobdefs, which we look up).
+ */
+void store_defs(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ RES *res;
+
+ lex_get_token(lc, T_NAME);
+ if (pass == 2) {
+ Dmsg2(300, "Code=%d name=%s\n", item->code, lc->str);
+ res = GetResWithName(item->code, lc->str);
+ if (res == NULL) {
+ scan_err3(lc, _("Missing config Resource \"%s\" referenced on line %d : %s\n"),
+ lc->str, lc->line_no, lc->line);
+ }
+ /* for each item not set, we copy the field from res */
+#ifdef xxx
+ for (int i=0; item->name;; i++, item++) {
+ if (bit_is_set(i, res->item_present)) {
+ Dmsg2(300, "Item %d is present in %s\n", i, res->name);
+ } else {
+ Dmsg2(300, "Item %d is not present in %s\n", i, res->name);
+ }
+ }
+ /* ***FIXME **** add code */
+#endif
+ }
+ scan_to_eol(lc);
+}
+
+
+
+/* Store an integer at specified address */
+void store_int(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ lex_get_token(lc, T_INT32);
+ *(int *)(item->value) = lc->int32_val;
+ scan_to_eol(lc);
+ set_bit(index, res_all.hdr.item_present);
+}
+
+/* Store a positive integer at specified address */
+void store_pint(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ lex_get_token(lc, T_PINT32);
+ *(int *)(item->value) = lc->pint32_val;
+ scan_to_eol(lc);
+ set_bit(index, res_all.hdr.item_present);
+}
+
+
+/* Store an 64 bit integer at specified address */
+void store_int64(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ lex_get_token(lc, T_INT64);
+ *(int64_t *)(item->value) = lc->int64_val;
+ scan_to_eol(lc);
+ set_bit(index, res_all.hdr.item_present);
+}
+
+/* Store a size in bytes */
+void store_size(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ int token;
+ uint64_t uvalue;
+
+ Dmsg0(400, "Enter store_size\n");
+ token = lex_get_token(lc, T_ALL);
+ errno = 0;
+ switch (token) {
+ case T_NUMBER:
+ 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);
+ }
+ *(uint64_t *)(item->value) = uvalue;
+ break;
+ default:
+ scan_err1(lc, _("expected a size, got: %s"), lc->str);
+ break;
+ }
+ scan_to_eol(lc);
+ set_bit(index, res_all.hdr.item_present);
+ Dmsg0(400, "Leave store_size\n");
+}
+
+
+/* Store a time period in seconds */
+void store_time(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ int token;
+ utime_t utime;
+ char period[500];
+
+ token = lex_get_token(lc, T_ALL);
+ errno = 0;
+ switch (token) {
+ case T_NUMBER:
+ case T_IDENTIFIER:
+ case T_UNQUOTED_STRING:
+ bstrncpy(period, lc->str, sizeof(period));
+ if (lc->ch == ' ') {
+ token = lex_get_token(lc, T_ALL);
+ switch (token) {
+ case T_IDENTIFIER:
+ case T_UNQUOTED_STRING:
+ bstrncat(period, lc->str, sizeof(period));
+ break;
+ }
+ }
+ if (!duration_to_utime(period, &utime)) {
+ 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);
+ break;
+ }
+ if (token != T_EOL) {
+ scan_to_eol(lc);
+ }
+ set_bit(index, res_all.hdr.item_present);
+}
+
+
+/* Store a yes/no in a bit field */
+void store_yesno(LEX *lc, RES_ITEM *item, int index, int pass)
+{
+ lex_get_token(lc, T_NAME);
+ if (strcasecmp(lc->str, "yes") == 0) {
+ *(int *)(item->value) |= item->code;
+ } 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_to_eol(lc);
+ set_bit(index, res_all.hdr.item_present);
+}
+
+
+/* #define TRACE_RES */
+
+void b_LockRes(const char *file, int line)
+{
+ int errstat;
+#ifdef TRACE_RES
+ Dmsg4(000, "LockRes %d,%d at %s:%d\n", res_locked, res_lock.w_active,
+ file, line);
+#endif
+ if ((errstat=rwl_writelock(&res_lock)) != 0) {
+ Emsg3(M_ABORT, 0, "rwl_writelock failure at %s:%d: ERR=%s\n",
+ file, line, strerror(errstat));
+ }
+ res_locked++;
+}
+
+void b_UnlockRes(const char *file, int line)
+{
+ int errstat;
+ res_locked--;
+#ifdef TRACE_RES
+ Dmsg4(000, "UnLockRes %d,%d at %s:%d\n", res_locked, res_lock.w_active,
+ file, line);
+#endif
+ if ((errstat=rwl_writeunlock(&res_lock)) != 0) {
+ Emsg3(M_ABORT, 0, "rwl_writeunlock failure at %s:%d:. ERR=%s\n",
+ file, line, strerror(errstat));
+ }
+}
+
+/*
+ * Return resource of type rcode that matches name
+ */
+RES *
+GetResWithName(int rcode, char *name)
+{
+ RES *res;
+ int rindex = rcode - r_first;
+
+ LockRes();
+ res = resources[rindex].res_head;
+ while (res) {
+ if (strcmp(res->name, name) == 0) {
+ break;
+ }
+ res = res->next;
+ }
+ UnlockRes();
+ return res;
+
+}
+
+/*
+ * Return next resource of type rcode. On first
+ * call second arg (res) is NULL, on subsequent
+ * calls, it is called with previous value.
+ */
+RES *
+GetNextRes(int rcode, RES *res)
+{
+ RES *nres;
+ int rindex = rcode - r_first;
+
+
+ if (!res_locked) {
+ Emsg0(M_ABORT, 0, "Resource chain not locked.\n");
+ }
+ if (res == NULL) {
+ nres = resources[rindex].res_head;
+ } else {
+ nres = res->next;
+ }
+ return nres;
+}
+
+
+/* Parser state */
+enum parse_state {
+ p_none,
+ p_resource
+};
+
+/*********************************************************************
+ *
+ * Parse configuration file
+ *
+ */
+void
+parse_config(char *cf)
+{
+ LEX *lc = NULL;
+ int token, i, pass;
+ int res_type = 0;
+ enum parse_state state = p_none;
+ RES_ITEM *items = NULL;
+ int level = 0;
+
+ /* Make two passes. The first builds the name symbol table,
+ * and the second picks up the items.
+ */
+ Dmsg0(300, "Enter parse_config()\n");
+ for (pass=1; pass <= 2; pass++) {
+ Dmsg1(300, "parse_config pass %d\n", pass);
+ lc = lex_open_file(lc, cf, NULL);
+ while ((token=lex_get_token(lc, T_ALL)) != T_EOF) {
+ Dmsg1(300, "parse got token=%s\n", lex_tok_to_str(token));
+ switch (state) {
+ case p_none:
+ if (token == T_EOL) {
+ break;
+ }
+ if (token != T_IDENTIFIER) {
+ scan_err1(lc, _("Expected a Resource name identifier, got: %s"), lc->str);
+ /* NOT REACHED */
+ }
+ for (i=0; resources[i].name; i++)
+ if (strcasecmp(resources[i].name, lc->str) == 0) {
+ state = p_resource;
+ items = resources[i].items;
+ res_type = resources[i].rcode;
+ init_resource(res_type, items);
+ break;
+ }
+ if (state == p_none) {
+ scan_err1(lc, _("expected resource name, got: %s"), lc->str);
+ /* NOT REACHED */
+ }
+ break;
+ case p_resource:
+ switch (token) {
+ case T_BOB:
+ level++;
+ break;
+ case T_IDENTIFIER:
+ if (level != 1) {
+ scan_err1(lc, _("not in resource definition: %s"), lc->str);
+ /* NOT REACHED */
+ }
+ for (i=0; items[i].name; i++) {
+ if (strcasecmp(items[i].name, lc->str) == 0) {
+ /* If the ITEM_NO_EQUALS flag is set we do NOT
+ * scan for = after the keyword */
+ if (!(items[i].flags & ITEM_NO_EQUALS)) {
+ token = lex_get_token(lc, T_ALL);
+ Dmsg1 (300, "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);
+ /* NOT REACHED */
+ }
+ }
+ Dmsg1(300, "calling handler for %s\n", items[i].name);
+ /* Call item handler */
+ items[i].handler(lc, &items[i], i, pass);
+ i = -1;
+ break;
+ }
+ }
+ if (i >= 0) {
+ Dmsg2(300, "level=%d id=%s\n", level, lc->str);
+ Dmsg1(300, "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);
+ /* NOT REACHED */
+ }
+ break;
+
+ case T_EOB:
+ level--;
+ state = p_none;
+ Dmsg0(300, "T_EOB => define new resource\n");
+ save_resource(res_type, items, pass); /* save resource */
+ break;
+
+ case T_EOL:
+ break;
+
+ default:
+ 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);
+ /* NOT REACHED */
+ }
+ }
+ if (state != p_none) {
+ scan_err0(lc, _("End of conf file reached with unclosed resource."));
+ }
+ if (debug_level > 50 && pass == 2) {
+ int i;
+ for (i=r_first; i<=r_last; i++) {
+ dump_resource(i, resources[i-r_first].res_head, prtmsg, NULL);
+ }
+ }
+ lc = lex_close_file(lc);
+ }
+ Dmsg0(300, "Leave parse_config()\n");
+}
+
+/*********************************************************************
+ *
+ * Free configuration resources
+ *
+ */
+void free_config_resources()
+{
+ for (int i=r_first; i<=r_last; i++) {
+ free_resource(resources[i-r_first].res_head, i);
+ resources[i-r_first].res_head = NULL;
+ }
+}
+
+RES **save_config_resources()
+{
+ int num = r_last - r_first + 1;
+ RES **res = (RES **)malloc(num*sizeof(RES *));
+ for (int i=0; i<num; i++) {
+ res[i] = resources[i].res_head;
+ resources[i].res_head = NULL;
+ }
+ return res;
+}
projects / bacula / bacula / commitdiff