From: Kern Sibbald Date: Sat, 10 Apr 2004 08:33:26 +0000 (+0000) Subject: Add back changed files X-Git-Tag: Release-1.34.1~62 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=d71d24c787e15155010033963bce240115909e33;p=bacula%2Fbacula Add back changed files git-svn-id: https://bacula.svn.sourceforge.net/svnroot/bacula/trunk@1191 91ce42f0-d328-0410-95d8-f526ca767f89 --- diff --git a/bacula/src/lib/jcr.c b/bacula/src/lib/jcr.c new file mode 100755 index 0000000000..513aed1242 --- /dev/null +++ b/bacula/src/lib/jcr.c @@ -0,0 +1,644 @@ +/* + * 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; ijob_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 */ +} diff --git a/bacula/src/lib/message.c b/bacula/src/lib/message.c new file mode 100755 index 0000000000..e6cb8f010b --- /dev/null +++ b/bacula/src/lib/message.c @@ -0,0 +1,1191 @@ +/* + * 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); +} diff --git a/bacula/src/lib/parse_conf.c b/bacula/src/lib/parse_conf.c new file mode 100755 index 0000000000..429edf4d95 --- /dev/null +++ b/bacula/src/lib/parse_conf.c @@ -0,0 +1,821 @@ +/* + * 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