git.sur5r.net Git - bacula/bacula/blob - bacula/src/lib/message.c

   1 /*
   2  * Bacula message handling routines
   3  *
   4  *   Kern Sibbald, April 2000
   5  *
   6  *   Version $Id$
   7  *
   8  */
   9
  10 /*
  11    Copyright (C) 2000-2004 Kern Sibbald and John Walker
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License as
  15    published by the Free Software Foundation; either version 2 of
  16    the License, or (at your option) any later version.
  17
  18    This program is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  21    General Public License for more details.
  22
  23    You should have received a copy of the GNU General Public
  24    License along with this program; if not, write to the Free
  25    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  26    MA 02111-1307, USA.
  27
  28  */
  29
  30
  31 #include "bacula.h"
  32 #include "jcr.h"
  33
  34 #if !defined(HAVE_CONSOLE)
  35 #if defined(HAVE_CYGWIN) || defined(HAVE_WIN32)
  36 #include <windows.h>
  37 #endif
  38 #endif
  39
  40 #define FULL_LOCATION 1               /* set for file:line in Debug messages */
  41
  42 /*
  43  *  This is where we define "Globals" because all the
  44  *    daemons include this file.
  45  */
  46 const char *working_directory = NULL;       /* working directory path stored here */
  47 int verbose = 0;                      /* increase User messages */
  48 int debug_level = 0;                  /* debug level */
  49 time_t daemon_start_time = 0;         /* Daemon start time */
  50 const char *version = VERSION " (" BDATE ")";
  51 char my_name[30];                     /* daemon name is stored here */
  52 char *exepath = (char *)NULL;
  53 char *exename = (char *)NULL;
  54 int console_msg_pending = 0;
  55 char con_fname[500];                  /* Console filename */
  56 FILE *con_fd = NULL;                  /* Console file descriptor */
  57 brwlock_t con_lock;                   /* Console lock structure */
  58
  59 #ifdef HAVE_POSTGRESQL
  60 char catalog_db[] = "PostgreSQL";
  61 #else
  62 #ifdef HAVE_MYSQL
  63 char catalog_db[] = "MySQL";
  64 #else
  65 #ifdef HAVE_SQLITE
  66 char catalog_db[] = "SQLite";
  67 #else
  68 char catalog_db[] = "Internal";
  69 #endif
  70 #endif
  71 #endif
  72
  73 const char *host_os = HOST_OS;
  74 const char *distname = DISTNAME;
  75 const char *distver = DISTVER;
  76 static FILE *trace_fd = NULL;
  77 #ifdef HAVE_WIN32
  78 static bool trace = true;
  79 #else
  80 static bool trace = false;
  81 #endif
  82
  83 /* Forward referenced functions */
  84
  85 /* Imported functions */
  86
  87
  88 /* Static storage */
  89
  90 /* Used to allow only one thread close the daemon messages at a time */
  91 static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  92 static MSGS *daemon_msgs;              /* global messages */
  93
  94
  95 /*
  96  * Set daemon name. Also, find canonical execution
  97  *  path.  Note, exepath has spare room for tacking on
  98  *  the exename so that we can reconstruct the full name.
  99  *
 100  * Note, this routine can get called multiple times
 101  *  The second time is to put the name as found in the
 102  *  Resource record. On the second call, generally,
 103  *  argv is NULL to avoid doing the path code twice.
 104  */
 105 #define BTRACE_EXTRA 20
 106 void my_name_is(int argc, char *argv[], const char *name)
 107 {
 108    char *l, *p, *q;
 109    char cpath[1024];
 110    int len;
 111
 112    bstrncpy(my_name, name, sizeof(my_name));
 113    if (argc>0 && argv && argv[0]) {
 114       /* strip trailing filename and save exepath */
 115       for (l=p=argv[0]; *p; p++) {
 116          if (*p == '/') {
 117             l = p;                       /* set pos of last slash */
 118          }
 119       }
 120       if (*l == '/') {
 121          l++;
 122       } else {
 123          l = argv[0];
 124 #if defined(HAVE_CYGWIN) || defined(HAVE_WIN32)
 125          /* On Windows allow c: junk */
 126          if (l[1] == ':') {
 127             l += 2;
 128          }
 129 #endif
 130       }
 131       len = strlen(l) + 1;
 132       if (exename) {
 133          free(exename);
 134       }
 135       exename = (char *)malloc(len);
 136       strcpy(exename, l);
 137
 138       if (exepath) {
 139          free(exepath);
 140       }
 141       exepath = (char *)malloc(strlen(argv[0]) + 1 + len);
 142       for (p=argv[0],q=exepath; p < l; ) {
 143          *q++ = *p++;
 144       }
 145       *q = 0;
 146       if (strchr(exepath, '.') || exepath[0] != '/') {
 147          if (getcwd(cpath, sizeof(cpath))) {
 148             free(exepath);
 149             exepath = (char *)malloc(strlen(cpath) + 1 + len);
 150             strcpy(exepath, cpath);
 151          }
 152       }
 153       Dmsg2(500, "exepath=%s\nexename=%s\n", exepath, exename);
 154    }
 155 }
 156
 157 /*
 158  * Initialize message handler for a daemon or a Job
 159  *   We make a copy of the MSGS resource passed, so it belows
 160  *   to the job or daemon and thus can be modified.
 161  *
 162  *   NULL for jcr -> initialize global messages for daemon
 163  *   non-NULL     -> initialize jcr using Message resource
 164  */
 165 void
 166 init_msg(JCR *jcr, MSGS *msg)
 167 {
 168    DEST *d, *dnew, *temp_chain = NULL;
 169    int i;
 170
 171    if (jcr == NULL && msg == NULL) {
 172       init_last_jobs_list();
 173    }
 174
 175 #ifndef HAVE_WIN32
 176    /*
 177     * Make sure we have fd's 0, 1, 2 open
 178     *  If we don't do this one of our sockets may open
 179     *  there and if we then use stdout, it could
 180     *  send total garbage to our socket.
 181     *
 182     */
 183    int fd;
 184    fd = open("/dev/null", O_RDONLY, 0644);
 185    if (fd > 2) {
 186       close(fd);
 187    } else {
 188       for(i=1; fd + i <= 2; i++) {
 189          dup2(fd, fd+i);
 190       }
 191    }
 192
 193 #endif
 194    /*
 195     * If msg is NULL, initialize global chain for STDOUT and syslog
 196     */
 197    if (msg == NULL) {
 198       daemon_msgs = (MSGS *)malloc(sizeof(MSGS));
 199       memset(daemon_msgs, 0, sizeof(MSGS));
 200       for (i=1; i<=M_MAX; i++) {
 201 #ifndef WIN32
 202          add_msg_dest(daemon_msgs, MD_STDOUT, i, NULL, NULL);
 203 #endif
 204          add_msg_dest(daemon_msgs, MD_SYSLOG, i, NULL, NULL);
 205       }
 206       Dmsg1(050, "Create daemon global message resource 0x%x\n", daemon_msgs);
 207       return;
 208    }
 209
 210    /*
 211     * Walk down the message resource chain duplicating it
 212     * for the current Job.
 213     */
 214    for (d=msg->dest_chain; d; d=d->next) {
 215       dnew = (DEST *)malloc(sizeof(DEST));
 216       memcpy(dnew, d, sizeof(DEST));
 217       dnew->next = temp_chain;
 218       dnew->fd = NULL;
 219       dnew->mail_filename = NULL;
 220       if (d->mail_cmd) {
 221          dnew->mail_cmd = bstrdup(d->mail_cmd);
 222       }
 223       if (d->where) {
 224          dnew->where = bstrdup(d->where);
 225       }
 226       temp_chain = dnew;
 227    }
 228
 229    if (jcr) {
 230       jcr->jcr_msgs = (MSGS *)malloc(sizeof(MSGS));
 231       memset(jcr->jcr_msgs, 0, sizeof(MSGS));
 232       jcr->jcr_msgs->dest_chain = temp_chain;
 233       memcpy(jcr->jcr_msgs->send_msg, msg->send_msg, sizeof(msg->send_msg));
 234    } else {
 235       /* If we have default values, release them now */
 236       if (daemon_msgs) {
 237          free_msgs_res(daemon_msgs);
 238       }
 239       daemon_msgs = (MSGS *)malloc(sizeof(MSGS));
 240       memset(daemon_msgs, 0, sizeof(MSGS));
 241       daemon_msgs->dest_chain = temp_chain;
 242       memcpy(daemon_msgs->send_msg, msg->send_msg, sizeof(msg->send_msg));
 243    }
 244    Dmsg2(250, "Copy message resource 0x%x to 0x%x\n", msg, temp_chain);
 245
 246 }
 247
 248 /* Initialize so that the console (User Agent) can
 249  * receive messages -- stored in a file.
 250  */
 251 void init_console_msg(const char *wd)
 252 {
 253    int fd;
 254
 255    bsnprintf(con_fname, sizeof(con_fname), "%s/%s.conmsg", wd, my_name);
 256    fd = open(con_fname, O_CREAT|O_RDWR|O_BINARY, 0600);
 257    if (fd == -1) {
 258       berrno be;
 259       Emsg2(M_ERROR_TERM, 0, _("Could not open console message file %s: ERR=%s\n"),
 260           con_fname, be.strerror());
 261    }
 262    if (lseek(fd, 0, SEEK_END) > 0) {
 263       console_msg_pending = 1;
 264    }
 265    close(fd);
 266    con_fd = fopen(con_fname, "a+");
 267    if (!con_fd) {
 268       berrno be;
 269       Emsg2(M_ERROR, 0, _("Could not open console message file %s: ERR=%s\n"),
 270           con_fname, be.strerror());
 271    }
 272    if (rwl_init(&con_lock) != 0) {
 273       berrno be;
 274       Emsg1(M_ERROR_TERM, 0, _("Could not get con mutex: ERR=%s\n"),
 275          be.strerror());
 276    }
 277 }
 278
 279 /*
 280  * Called only during parsing of the config file.
 281  *
 282  * Add a message destination. I.e. associate a message type with
 283  *  a destination (code).
 284  * Note, where in the case of dest_code FILE is a filename,
 285  *  but in the case of MAIL is a space separated list of
 286  *  email addresses, ...
 287  */
 288 void add_msg_dest(MSGS *msg, int dest_code, int msg_type, char *where, char *mail_cmd)
 289 {
 290    DEST *d;
 291    /*
 292     * First search the existing chain and see if we
 293     * can simply add this msg_type to an existing entry.
 294     */
 295    for (d=msg->dest_chain; d; d=d->next) {
 296       if (dest_code == d->dest_code && ((where == NULL && d->where == NULL) ||
 297                      (strcmp(where, d->where) == 0))) {
 298          Dmsg4(850, "Add to existing d=%x msgtype=%d destcode=%d where=%s\n",
 299              d, msg_type, dest_code, NPRT(where));
 300          set_bit(msg_type, d->msg_types);
 301          set_bit(msg_type, msg->send_msg);  /* set msg_type bit in our local */
 302          return;
 303       }
 304    }
 305    /* Not found, create a new entry */
 306    d = (DEST *)malloc(sizeof(DEST));
 307    memset(d, 0, sizeof(DEST));
 308    d->next = msg->dest_chain;
 309    d->dest_code = dest_code;
 310    set_bit(msg_type, d->msg_types);      /* set type bit in structure */
 311    set_bit(msg_type, msg->send_msg);     /* set type bit in our local */
 312    if (where) {
 313       d->where = bstrdup(where);
 314    }
 315    if (mail_cmd) {
 316       d->mail_cmd = bstrdup(mail_cmd);
 317    }
 318    Dmsg5(850, "add new d=%x msgtype=%d destcode=%d where=%s mailcmd=%s\n",
 319           d, msg_type, dest_code, NPRT(where), NPRT(d->mail_cmd));
 320    msg->dest_chain = d;
 321 }
 322
 323 /*
 324  * Called only during parsing of the config file.
 325  *
 326  * Remove a message destination
 327  */
 328 void rem_msg_dest(MSGS *msg, int dest_code, int msg_type, char *where)
 329 {
 330    DEST *d;
 331
 332    for (d=msg->dest_chain; d; d=d->next) {
 333       Dmsg2(850, "Remove_msg_dest d=%x where=%s\n", d, NPRT(d->where));
 334       if (bit_is_set(msg_type, d->msg_types) && (dest_code == d->dest_code) &&
 335           ((where == NULL && d->where == NULL) ||
 336                      (strcmp(where, d->where) == 0))) {
 337          Dmsg3(850, "Found for remove d=%x msgtype=%d destcode=%d\n",
 338                d, msg_type, dest_code);
 339          clear_bit(msg_type, d->msg_types);
 340          Dmsg0(850, "Return rem_msg_dest\n");
 341          return;
 342       }
 343    }
 344 }
 345
 346
 347 /*
 348  * Create a unique filename for the mail command
 349  */
 350 static void make_unique_mail_filename(JCR *jcr, POOLMEM *&name, DEST *d)
 351 {
 352    if (jcr) {
 353       Mmsg(name, "%s/%s.mail.%s.%d", working_directory, my_name,
 354                  jcr->Job, (int)(long)d);
 355    } else {
 356       Mmsg(name, "%s/%s.mail.%s.%d", working_directory, my_name,
 357                  my_name, (int)(long)d);
 358    }
 359    Dmsg1(850, "mailname=%s\n", name);
 360 }
 361
 362 /*
 363  * Open a mail pipe
 364  */
 365 static BPIPE *open_mail_pipe(JCR *jcr, POOLMEM *&cmd, DEST *d)
 366 {
 367    BPIPE *bpipe;
 368
 369    if (d->mail_cmd) {
 370       cmd = edit_job_codes(jcr, cmd, d->mail_cmd, d->where);
 371    } else {
 372       Mmsg(cmd, "/usr/lib/sendmail -F Bacula %s", d->where);
 373    }
 374    fflush(stdout);
 375
 376    if (!(bpipe = open_bpipe(cmd, 120, "rw"))) {
 377       berrno be;
 378       Jmsg(jcr, M_ERROR, 0, "open mail pipe %s failed: ERR=%s\n",
 379          cmd, be.strerror());
 380    }
 381
 382    /* If we had to use sendmail, add subject */
 383    if (!d->mail_cmd) {
 384        fprintf(bpipe->wfd, "Subject: Bacula Message\r\n\r\n");
 385    }
 386
 387    return bpipe;
 388 }
 389
 390 /*
 391  * Close the messages for this Messages resource, which means to close
 392  *  any open files, and dispatch any pending email messages.
 393  */
 394 void close_msg(JCR *jcr)
 395 {
 396    MSGS *msgs;
 397    DEST *d;
 398    BPIPE *bpipe;
 399    POOLMEM *cmd, *line;
 400    int len, stat;
 401
 402    Dmsg1(850, "Close_msg jcr=0x%x\n", jcr);
 403
 404    if (jcr == NULL) {                /* NULL -> global chain */
 405       msgs = daemon_msgs;
 406       P(mutex);                       /* only one thread walking the chain */
 407    } else {
 408       msgs = jcr->jcr_msgs;
 409       jcr->jcr_msgs = NULL;
 410    }
 411    if (msgs == NULL) {
 412       return;
 413    }
 414    Dmsg1(850, "===Begin close msg resource at 0x%x\n", msgs);
 415    cmd = get_pool_memory(PM_MESSAGE);
 416    for (d=msgs->dest_chain; d; ) {
 417       if (d->fd) {
 418          switch (d->dest_code) {
 419          case MD_FILE:
 420          case MD_APPEND:
 421             if (d->fd) {
 422                fclose(d->fd);            /* close open file descriptor */
 423             }
 424             break;
 425          case MD_MAIL:
 426          case MD_MAIL_ON_ERROR:
 427             Dmsg0(850, "Got MD_MAIL or MD_MAIL_ON_ERROR\n");
 428             if (!d->fd) {
 429                break;
 430             }
 431             if (d->dest_code == MD_MAIL_ON_ERROR && jcr &&
 432                 jcr->JobStatus == JS_Terminated) {
 433                goto rem_temp_file;
 434             }
 435
 436             if (!(bpipe=open_mail_pipe(jcr, cmd, d))) {
 437                Pmsg0(000, "open mail pipe failed.\n");
 438                goto rem_temp_file;
 439             }
 440             Dmsg0(850, "Opened mail pipe\n");
 441             len = d->max_len+10;
 442             line = get_memory(len);
 443             rewind(d->fd);
 444             while (fgets(line, len, d->fd)) {
 445                fputs(line, bpipe->wfd);
 446             }
 447             if (!close_wpipe(bpipe)) {       /* close write pipe sending mail */
 448                berrno be;
 449                Pmsg1(000, "close error: ERR=%s\n", be.strerror());
 450             }
 451
 452             /*
 453              * Since we are closing all messages, before "recursing"
 454              * make sure we are not closing the daemon messages, otherwise
 455              * kaboom.
 456              */
 457             if (msgs != daemon_msgs) {
 458                /* read what mail prog returned -- should be nothing */
 459                while (fgets(line, len, bpipe->rfd)) {
 460                   Jmsg1(jcr, M_INFO, 0, _("Mail prog: %s"), line);
 461                }
 462             }
 463
 464             stat = close_bpipe(bpipe);
 465             if (stat != 0 && msgs != daemon_msgs) {
 466                berrno be;
 467                be.set_errno(stat);
 468                Dmsg1(850, "Calling emsg. CMD=%s\n", cmd);
 469                Jmsg2(jcr, M_ERROR, 0, _("Mail program terminated in error.\n"
 470                                         "CMD=%s\n"
 471                                         "ERR=%s\n"), cmd, be.strerror());
 472             }
 473             free_memory(line);
 474 rem_temp_file:
 475             /* Remove temp file */
 476             fclose(d->fd);
 477             unlink(d->mail_filename);
 478             free_pool_memory(d->mail_filename);
 479             d->mail_filename = NULL;
 480             Dmsg0(850, "end mail or mail on error\n");
 481             break;
 482          default:
 483             break;
 484          }
 485          d->fd = NULL;
 486       }
 487       d = d->next;                    /* point to next buffer */
 488    }
 489    free_pool_memory(cmd);
 490    Dmsg0(850, "Done walking message chain.\n");
 491    if (jcr) {
 492       free_msgs_res(msgs);
 493       msgs = NULL;
 494    } else {
 495       V(mutex);
 496    }
 497    Dmsg0(850, "===End close msg resource\n");
 498 }
 499
 500 /*
 501  * Free memory associated with Messages resource
 502  */
 503 void free_msgs_res(MSGS *msgs)
 504 {
 505    DEST *d, *old;
 506
 507    /* Walk down the message chain releasing allocated buffers */
 508    for (d=msgs->dest_chain; d; ) {
 509       if (d->where) {
 510          free(d->where);
 511       }
 512       if (d->mail_cmd) {
 513          free(d->mail_cmd);
 514       }
 515       old = d;                        /* save pointer to release */
 516       d = d->next;                    /* point to next buffer */
 517       free(old);                      /* free the destination item */
 518    }
 519    msgs->dest_chain = NULL;
 520    free(msgs);                        /* free the head */
 521 }
 522
 523
 524 /*
 525  * Terminate the message handler for good.
 526  * Release the global destination chain.
 527  *
 528  * Also, clean up a few other items (cons, exepath). Note,
 529  *   these really should be done elsewhere.
 530  */
 531 void term_msg()
 532 {
 533    Dmsg0(850, "Enter term_msg\n");
 534    close_msg(NULL);                   /* close global chain */
 535    free_msgs_res(daemon_msgs);        /* free the resources */
 536    daemon_msgs = NULL;
 537    if (con_fd) {
 538       fflush(con_fd);
 539       fclose(con_fd);
 540       con_fd = NULL;
 541    }
 542    if (exepath) {
 543       free(exepath);
 544       exepath = NULL;
 545    }
 546    if (exename) {
 547       free(exename);
 548       exename = NULL;
 549    }
 550    if (trace_fd) {
 551       fclose(trace_fd);
 552       trace_fd = NULL;
 553    }
 554    term_last_jobs_list();
 555 }
 556
 557
 558
 559 /*
 560  * Handle sending the message to the appropriate place
 561  */
 562 void dispatch_message(JCR *jcr, int type, time_t mtime, char *msg)
 563 {
 564     DEST *d;
 565     char dt[MAX_TIME_LENGTH];
 566     POOLMEM *mcmd;
 567     int len, dtlen;
 568     MSGS *msgs;
 569     BPIPE *bpipe;
 570
 571     Dmsg2(850, "Enter dispatch_msg type=%d msg=%s", type, msg);
 572
 573     /*
 574      * Most messages are prefixed by a date and time. If mtime is
 575      *  zero, then we use the current time.  If mtime is 1 (special
 576      *  kludge), we do not prefix the date and time. Otherwise,
 577      *  we assume mtime is a time_t and use it.
 578      */
 579     if (mtime == 0) {
 580        mtime = time(NULL);
 581     }
 582     if (mtime == 1) {
 583        *dt = 0;
 584        dtlen = 0;
 585     } else {
 586        bstrftime_ny(dt, sizeof(dt), mtime);
 587        dtlen = strlen(dt);
 588        dt[dtlen++] = ' ';
 589        dt[dtlen] = 0;
 590     }
 591
 592     if (type == M_ABORT || type == M_ERROR_TERM) {
 593 #ifndef HAVE_WIN32
 594        fputs(dt, stdout);
 595        fputs(msg, stdout);         /* print this here to INSURE that it is printed */
 596        fflush(stdout);
 597 #endif
 598     }
 599
 600     /* Now figure out where to send the message */
 601     msgs = NULL;
 602     if (jcr) {
 603        msgs = jcr->jcr_msgs;
 604     }
 605     if (msgs == NULL) {
 606        msgs = daemon_msgs;
 607     }
 608     for (d=msgs->dest_chain; d; d=d->next) {
 609        if (bit_is_set(type, d->msg_types)) {
 610           switch (d->dest_code) {
 611              case MD_CONSOLE:
 612                 Dmsg1(850, "CONSOLE for following msg: %s", msg);
 613                 if (!con_fd) {
 614                    con_fd = fopen(con_fname, "a+");
 615                    Dmsg0(850, "Console file not open.\n");
 616                 }
 617                 if (con_fd) {
 618                    Pw(con_lock);      /* get write lock on console message file */
 619                    errno = 0;
 620                    if (dtlen) {
 621                       fwrite(dt, dtlen, 1, con_fd);
 622                    }
 623                    len = strlen(msg);
 624                    if (len > 0) {
 625                       fwrite(msg, len, 1, con_fd);
 626                       if (msg[len-1] != '\n') {
 627                          fwrite("\n", 2, 1, con_fd);
 628                       }
 629                    } else {
 630                       fwrite("\n", 2, 1, con_fd);
 631                    }
 632                    fflush(con_fd);
 633                    console_msg_pending = TRUE;
 634                    Vw(con_lock);
 635                 }
 636                 break;
 637              case MD_SYSLOG:
 638                 Dmsg1(850, "SYSLOG for collowing msg: %s\n", msg);
 639                 /*
 640                  * We really should do an openlog() here.
 641                  */
 642                 syslog(LOG_DAEMON|LOG_ERR, "%s", msg);
 643                 break;
 644              case MD_OPERATOR:
 645                 Dmsg1(850, "OPERATOR for following msg: %s\n", msg);
 646                 mcmd = get_pool_memory(PM_MESSAGE);
 647                 if ((bpipe=open_mail_pipe(jcr, mcmd, d))) {
 648                    int stat;
 649                    fputs(dt, bpipe->wfd);
 650                    fputs(msg, bpipe->wfd);
 651                    /* Messages to the operator go one at a time */
 652                    stat = close_bpipe(bpipe);
 653                    if (stat != 0) {
 654                       berrno be;
 655                       be.set_errno(stat);
 656                       Qmsg2(jcr, M_ERROR, 0, _("Operator mail program terminated in error.\n"
 657                             "CMD=%s\n"
 658                             "ERR=%s\n"), mcmd, be.strerror());
 659                    }
 660                 }
 661                 free_pool_memory(mcmd);
 662                 break;
 663              case MD_MAIL:
 664              case MD_MAIL_ON_ERROR:
 665                 Dmsg1(850, "MAIL for following msg: %s", msg);
 666                 if (!d->fd) {
 667                    POOLMEM *name = get_pool_memory(PM_MESSAGE);
 668                    make_unique_mail_filename(jcr, name, d);
 669                    d->fd = fopen(name, "w+");
 670                    if (!d->fd) {
 671                       berrno be;
 672                       d->fd = stdout;
 673                       Qmsg2(jcr, M_ERROR, 0, "fopen %s failed: ERR=%s\n", name,
 674                             be.strerror());
 675                       d->fd = NULL;
 676                       free_pool_memory(name);
 677                       break;
 678                    }
 679                    d->mail_filename = name;
 680                 }
 681                 fputs(dt, d->fd);
 682                 len = strlen(msg) + dtlen;;
 683                 if (len > d->max_len) {
 684                    d->max_len = len;      /* keep max line length */
 685                 }
 686                 fputs(msg, d->fd);
 687                 break;
 688              case MD_FILE:
 689                 Dmsg1(850, "FILE for following msg: %s", msg);
 690                 if (!d->fd) {
 691                    d->fd = fopen(d->where, "w+");
 692                    if (!d->fd) {
 693                       berrno be;
 694                       d->fd = stdout;
 695                       Qmsg2(jcr, M_ERROR, 0, "fopen %s failed: ERR=%s\n", d->where,
 696                             be.strerror());
 697                       d->fd = NULL;
 698                       break;
 699                    }
 700                 }
 701                 fputs(dt, d->fd);
 702                 fputs(msg, d->fd);
 703                 break;
 704              case MD_APPEND:
 705                 Dmsg1(850, "APPEND for following msg: %s", msg);
 706                 if (!d->fd) {
 707                    d->fd = fopen(d->where, "a");
 708                    if (!d->fd) {
 709                       berrno be;
 710                       d->fd = stdout;
 711                       Qmsg2(jcr, M_ERROR, 0, "fopen %s failed: ERR=%s\n", d->where,
 712                             be.strerror());
 713                       d->fd = NULL;
 714                       break;
 715                    }
 716                 }
 717                 fputs(dt, d->fd);
 718                 fputs(msg, d->fd);
 719                 break;
 720              case MD_DIRECTOR:
 721                 Dmsg1(850, "DIRECTOR for following msg: %s", msg);
 722                 if (jcr && jcr->dir_bsock && !jcr->dir_bsock->errors) {
 723                    bnet_fsend(jcr->dir_bsock, "Jmsg Job=%s type=%d level=%d %s",
 724                       jcr->Job, type, mtime, msg);
 725                 }
 726                 break;
 727              case MD_STDOUT:
 728                 Dmsg1(850, "STDOUT for following msg: %s", msg);
 729                 if (type != M_ABORT && type != M_ERROR_TERM) { /* already printed */
 730                    fputs(dt, stdout);
 731                    fputs(msg, stdout);
 732                 }
 733                 break;
 734              case MD_STDERR:
 735                 Dmsg1(850, "STDERR for following msg: %s", msg);
 736                 fputs(dt, stderr);
 737                 fputs(msg, stderr);
 738                 break;
 739              default:
 740                 break;
 741           }
 742        }
 743     }
 744 }
 745
 746
 747 /*********************************************************************
 748  *
 749  *  This subroutine prints a debug message if the level number
 750  *  is less than or equal the debug_level. File and line numbers
 751  *  are included for more detail if desired, but not currently
 752  *  printed.
 753  *
 754  *  If the level is negative, the details of file and line number
 755  *  are not printed.
 756  */
 757 void
 758 d_msg(const char *file, int line, int level, const char *fmt,...)
 759 {
 760     char      buf[5000];
 761     int       len;
 762     va_list   arg_ptr;
 763     int       details = TRUE;
 764
 765     if (level < 0) {
 766        details = FALSE;
 767        level = -level;
 768     }
 769
 770     if (level <= debug_level) {
 771 #ifdef FULL_LOCATION
 772        if (details) {
 773           /* visual studio passes the whole path to the file as well
 774            * which makes for very long lines
 775            */
 776           const char *f = strrchr(file, '\\');
 777           if (f) file = f + 1;
 778           len = bsnprintf(buf, sizeof(buf), "%s: %s:%d ", my_name, file, line);
 779        } else {
 780           len = 0;
 781        }
 782 #else
 783        len = 0;
 784 #endif
 785        va_start(arg_ptr, fmt);
 786        bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
 787        va_end(arg_ptr);
 788
 789        /*
 790         * Used the "trace on" command in the console to turn on
 791         *  output to the trace file.  "trace off" will close the file.
 792         */
 793        if (trace) {
 794           if (!trace_fd) {
 795              bsnprintf(buf, sizeof(buf), "%s/bacula.trace", working_directory ? working_directory : ".");
 796              trace_fd = fopen(buf, "a+");
 797           }
 798           if (trace_fd) {
 799              fputs(buf, trace_fd);
 800              fflush(trace_fd);
 801           }
 802        } else {   /* not tracing */
 803           fputs(buf, stdout);
 804        }
 805     }
 806 }
 807
 808 /*
 809  * Set trace flag on/off. If argument is negative, there is no change
 810  */
 811 void set_trace(int trace_flag)
 812 {
 813    if (trace_flag < 0) {
 814       return;
 815    } else if (trace_flag > 0) {
 816       trace = true;
 817    } else {
 818       trace = false;
 819    }
 820    if (!trace && trace_fd) {
 821       FILE *ltrace_fd = trace_fd;
 822       trace_fd = NULL;
 823       bmicrosleep(0, 100000);         /* yield to prevent seg faults */
 824       fclose(ltrace_fd);
 825    }
 826 }
 827
 828 bool get_trace(void)
 829 {
 830    return trace;
 831 }
 832
 833 /*********************************************************************
 834  *
 835  *  This subroutine prints a message regardless of the debug level
 836  *
 837  *  If the level is negative, the details of file and line number
 838  *  are not printed.
 839  */
 840 void
 841 p_msg(const char *file, int line, int level, const char *fmt,...)
 842 {
 843     char      buf[5000];
 844     int       len;
 845     va_list   arg_ptr;
 846
 847 #ifdef FULL_LOCATION
 848     if (level >= 0) {
 849        len = bsnprintf(buf, sizeof(buf), "%s: %s:%d ", my_name, file, line);
 850     } else {
 851        len = 0;
 852     }
 853 #else
 854     len = 0;
 855 #endif
 856     va_start(arg_ptr, fmt);
 857     bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
 858     va_end(arg_ptr);
 859     fputs(buf, stdout);
 860 }
 861
 862
 863 /*********************************************************************
 864  *
 865  *  subroutine writes a debug message to the trace file if the level number
 866  *  is less than or equal the debug_level. File and line numbers
 867  *  are included for more detail if desired, but not currently
 868  *  printed.
 869  *
 870  *  If the level is negative, the details of file and line number
 871  *  are not printed.
 872  */
 873 void
 874 t_msg(const char *file, int line, int level, const char *fmt,...)
 875 {
 876     char      buf[5000];
 877     int       len;
 878     va_list   arg_ptr;
 879     int       details = TRUE;
 880
 881     if (level < 0) {
 882        details = FALSE;
 883        level = -level;
 884     }
 885
 886     if (level <= debug_level) {
 887        if (!trace_fd) {
 888           bsnprintf(buf, sizeof(buf), "%s/bacula.trace", working_directory);
 889           trace_fd = fopen(buf, "a+");
 890        }
 891
 892 #ifdef FULL_LOCATION
 893        if (details) {
 894           len = bsnprintf(buf, sizeof(buf), "%s: %s:%d ", my_name, file, line);
 895        } else {
 896           len = 0;
 897        }
 898 #else
 899        len = 0;
 900 #endif
 901        va_start(arg_ptr, fmt);
 902        bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
 903        va_end(arg_ptr);
 904        if (trace_fd != NULL) {
 905            fputs(buf, trace_fd);
 906            fflush(trace_fd);
 907        }
 908    }
 909 }
 910
 911
 912
 913 /* *********************************************************
 914  *
 915  * print an error message
 916  *
 917  */
 918 void
 919 e_msg(const char *file, int line, int type, int level, const char *fmt,...)
 920 {
 921     char     buf[5000];
 922     va_list   arg_ptr;
 923     int len;
 924
 925     /*
 926      * Check if we have a message destination defined.
 927      * We always report M_ABORT and M_ERROR_TERM
 928      */
 929     if (!daemon_msgs || ((type != M_ABORT && type != M_ERROR_TERM) &&
 930                          !bit_is_set(type, daemon_msgs->send_msg))) {
 931        return;                        /* no destination */
 932     }
 933     switch (type) {
 934     case M_ABORT:
 935        len = bsnprintf(buf, sizeof(buf), "%s: ABORTING due to ERROR in %s:%d\n",
 936                my_name, file, line);
 937        break;
 938     case M_ERROR_TERM:
 939        len = bsnprintf(buf, sizeof(buf), "%s: ERROR TERMINATION at %s:%d\n",
 940                my_name, file, line);
 941        break;
 942     case M_FATAL:
 943        if (level == -1)            /* skip details */
 944           len = bsnprintf(buf, sizeof(buf), "%s: Fatal Error because: ", my_name);
 945        else
 946           len = bsnprintf(buf, sizeof(buf), "%s: Fatal Error at %s:%d because:\n", my_name, file, line);
 947        break;
 948     case M_ERROR:
 949        if (level == -1)            /* skip details */
 950           len = bsnprintf(buf, sizeof(buf), "%s: ERROR: ", my_name);
 951        else
 952           len = bsnprintf(buf, sizeof(buf), "%s: ERROR in %s:%d ", my_name, file, line);
 953        break;
 954     case M_WARNING:
 955        len = bsnprintf(buf, sizeof(buf), "%s: Warning: ", my_name);
 956        break;
 957     case M_SECURITY:
 958        len = bsnprintf(buf, sizeof(buf), "%s: Security violation: ", my_name);
 959        break;
 960     default:
 961        len = bsnprintf(buf, sizeof(buf), "%s: ", my_name);
 962        break;
 963     }
 964
 965     va_start(arg_ptr, fmt);
 966     bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
 967     va_end(arg_ptr);
 968
 969     dispatch_message(NULL, type, 0, buf);
 970
 971     if (type == M_ABORT) {
 972        char *p = 0;
 973        p[0] = 0;                      /* generate segmentation violation */
 974     }
 975     if (type == M_ERROR_TERM) {
 976        exit(1);
 977     }
 978 }
 979
 980 /* *********************************************************
 981  *
 982  * Generate a Job message
 983  *
 984  */
 985 void
 986 Jmsg(JCR *jcr, int type, time_t mtime, const char *fmt,...)
 987 {
 988     char     rbuf[5000];
 989     va_list   arg_ptr;
 990     int len;
 991     MSGS *msgs;
 992     const char *job;
 993
 994
 995     Dmsg1(850, "Enter Jmsg type=%d\n", type);
 996
 997     /* Special case for the console, which has a dir_bsock and JobId==0,
 998      *  in that case, we send the message directly back to the
 999      *  dir_bsock.
1000      */
1001     if (jcr && jcr->JobId == 0 && jcr->dir_bsock) {
1002        BSOCK *dir = jcr->dir_bsock;
1003        va_start(arg_ptr, fmt);
1004        dir->msglen = bvsnprintf(dir->msg, sizeof_pool_memory(dir->msg),
1005                                 fmt, arg_ptr);
1006        va_end(arg_ptr);
1007        bnet_send(jcr->dir_bsock);
1008        return;
1009     }
1010
1011     msgs = NULL;
1012     job = NULL;
1013     if (jcr) {
1014        msgs = jcr->jcr_msgs;
1015        job = jcr->Job;
1016     }
1017     if (!msgs) {
1018        msgs = daemon_msgs;            /* if no jcr, we use daemon handler */
1019     }
1020     if (!job) {
1021        job = "";                      /* Set null job name if none */
1022     }
1023
1024     /*
1025      * Check if we have a message destination defined.
1026      * We always report M_ABORT and M_ERROR_TERM
1027      */
1028     if (msgs && (type != M_ABORT && type != M_ERROR_TERM) &&
1029          !bit_is_set(type, msgs->send_msg)) {
1030        return;                        /* no destination */
1031     }
1032     switch (type) {
1033     case M_ABORT:
1034        len = bsnprintf(rbuf, sizeof(rbuf), "%s ABORTING due to ERROR\n", my_name);
1035        break;
1036     case M_ERROR_TERM:
1037        len = bsnprintf(rbuf, sizeof(rbuf), "%s ERROR TERMINATION\n", my_name);
1038        break;
1039     case M_FATAL:
1040        len = bsnprintf(rbuf, sizeof(rbuf), "%s: %s Fatal error: ", my_name, job);
1041        if (jcr) {
1042           set_jcr_job_status(jcr, JS_FatalError);
1043        }
1044        break;
1045     case M_ERROR:
1046        len = bsnprintf(rbuf, sizeof(rbuf), "%s: %s Error: ", my_name, job);
1047        if (jcr) {
1048           jcr->Errors++;
1049        }
1050        break;
1051     case M_WARNING:
1052        len = bsnprintf(rbuf, sizeof(rbuf), "%s: %s Warning: ", my_name, job);
1053        break;
1054     case M_SECURITY:
1055        len = bsnprintf(rbuf, sizeof(rbuf), "%s: %s Security violation: ", my_name, job);
1056        break;
1057     default:
1058        len = bsnprintf(rbuf, sizeof(rbuf), "%s: ", my_name);
1059        break;
1060     }
1061
1062     va_start(arg_ptr, fmt);
1063     bvsnprintf(rbuf+len,  sizeof(rbuf)-len, fmt, arg_ptr);
1064     va_end(arg_ptr);
1065
1066     dispatch_message(jcr, type, mtime, rbuf);
1067
1068     if (type == M_ABORT){
1069        char *p = 0;
1070        p[0] = 0;                      /* generate segmentation violation */
1071     }
1072     if (type == M_ERROR_TERM) {
1073        exit(1);
1074     }
1075 }
1076
1077 /*
1078  * If we come here, prefix the message with the file:line-number,
1079  *  then pass it on to the normal Jmsg routine.
1080  */
1081 void j_msg(const char *file, int line, JCR *jcr, int type, time_t mtime, const char *fmt,...)
1082 {
1083    va_list   arg_ptr;
1084    int i, len, maxlen;
1085    POOLMEM *pool_buf;
1086
1087    pool_buf = get_pool_memory(PM_EMSG);
1088    i = Mmsg(pool_buf, "%s:%d ", file, line);
1089
1090    for (;;) {
1091       maxlen = sizeof_pool_memory(pool_buf) - i - 1;
1092       va_start(arg_ptr, fmt);
1093       len = bvsnprintf(pool_buf+i, maxlen, fmt, arg_ptr);
1094       va_end(arg_ptr);
1095       if (len < 0 || len >= (maxlen-5)) {
1096          pool_buf = realloc_pool_memory(pool_buf, maxlen + i + maxlen/2);
1097          continue;
1098       }
1099       break;
1100    }
1101
1102    Jmsg(jcr, type, mtime, "%s", pool_buf);
1103    free_memory(pool_buf);
1104 }
1105
1106
1107 /*
1108  * Edit a message into a Pool memory buffer, with file:lineno
1109  */
1110 int m_msg(const char *file, int line, POOLMEM **pool_buf, const char *fmt, ...)
1111 {
1112    va_list   arg_ptr;
1113    int i, len, maxlen;
1114
1115    i = sprintf(*pool_buf, "%s:%d ", file, line);
1116
1117    for (;;) {
1118       maxlen = sizeof_pool_memory(*pool_buf) - i - 1;
1119       va_start(arg_ptr, fmt);
1120       len = bvsnprintf(*pool_buf+i, maxlen, fmt, arg_ptr);
1121       va_end(arg_ptr);
1122       if (len < 0 || len >= (maxlen-5)) {
1123          *pool_buf = realloc_pool_memory(*pool_buf, maxlen + i + maxlen/2);
1124          continue;
1125       }
1126       break;
1127    }
1128    return len;
1129 }
1130
1131 int m_msg(const char *file, int line, POOLMEM *&pool_buf, const char *fmt, ...)
1132 {
1133    va_list   arg_ptr;
1134    int i, len, maxlen;
1135
1136    i = sprintf(pool_buf, "%s:%d ", file, line);
1137
1138    for (;;) {
1139       maxlen = sizeof_pool_memory(pool_buf) - i - 1;
1140       va_start(arg_ptr, fmt);
1141       len = bvsnprintf(pool_buf+i, maxlen, fmt, arg_ptr);
1142       va_end(arg_ptr);
1143       if (len < 0 || len >= (maxlen-5)) {
1144          pool_buf = realloc_pool_memory(pool_buf, maxlen + i + maxlen/2);
1145          continue;
1146       }
1147       break;
1148    }
1149    return len;
1150 }
1151
1152
1153 /*
1154  * Edit a message into a Pool Memory buffer NO file:lineno
1155  *  Returns: string length of what was edited.
1156  */
1157 int Mmsg(POOLMEM **pool_buf, const char *fmt, ...)
1158 {
1159    va_list   arg_ptr;
1160    int len, maxlen;
1161
1162    for (;;) {
1163       maxlen = sizeof_pool_memory(*pool_buf) - 1;
1164       va_start(arg_ptr, fmt);
1165       len = bvsnprintf(*pool_buf, maxlen, fmt, arg_ptr);
1166       va_end(arg_ptr);
1167       if (len < 0 || len >= (maxlen-5)) {
1168          *pool_buf = realloc_pool_memory(*pool_buf, maxlen + maxlen/2);
1169          continue;
1170       }
1171       break;
1172    }
1173    return len;
1174 }
1175
1176 int Mmsg(POOLMEM *&pool_buf, const char *fmt, ...)
1177 {
1178    va_list   arg_ptr;
1179    int len, maxlen;
1180
1181    for (;;) {
1182       maxlen = sizeof_pool_memory(pool_buf) - 1;
1183       va_start(arg_ptr, fmt);
1184       len = bvsnprintf(pool_buf, maxlen, fmt, arg_ptr);
1185       va_end(arg_ptr);
1186       if (len < 0 || len >= (maxlen-5)) {
1187          pool_buf = realloc_pool_memory(pool_buf, maxlen + maxlen/2);
1188          continue;
1189       }
1190       break;
1191    }
1192    return len;
1193 }
1194
1195 int Mmsg(POOL_MEM &pool_buf, const char *fmt, ...)
1196 {
1197    va_list   arg_ptr;
1198    int len, maxlen;
1199
1200    for (;;) {
1201       maxlen = pool_buf.max_size() - 1;
1202       va_start(arg_ptr, fmt);
1203       len = bvsnprintf(pool_buf.c_str(), maxlen, fmt, arg_ptr);
1204       va_end(arg_ptr);
1205       if (len < 0 || len >= (maxlen-5)) {
1206          pool_buf.realloc_pm(maxlen + maxlen/2);
1207          continue;
1208       }
1209       break;
1210    }
1211    return len;
1212 }
1213
1214
1215 static pthread_mutex_t msg_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
1216
1217 /*
1218  * We queue messages rather than print them directly. This
1219  *  is generally used in low level routines (msg handler, bnet)
1220  *  to prevent recursion (i.e. if you are in the middle of
1221  *  sending a message, it is a bit messy to recursively call
1222  *  yourself when the bnet packet is not reentrant).
1223  */
1224 void Qmsg(JCR *jcr, int type, time_t mtime, const char *fmt,...)
1225 {
1226    va_list   arg_ptr;
1227    int len, maxlen;
1228    POOLMEM *pool_buf;
1229    MQUEUE_ITEM *item;
1230
1231    pool_buf = get_pool_memory(PM_EMSG);
1232
1233    for (;;) {
1234       maxlen = sizeof_pool_memory(pool_buf) - 1;
1235       va_start(arg_ptr, fmt);
1236       len = bvsnprintf(pool_buf, maxlen, fmt, arg_ptr);
1237       va_end(arg_ptr);
1238       if (len < 0 || len >= (maxlen-5)) {
1239          pool_buf = realloc_pool_memory(pool_buf, maxlen + maxlen/2);
1240          continue;
1241       }
1242       break;
1243    }
1244    item = (MQUEUE_ITEM *)malloc(sizeof(MQUEUE_ITEM) + strlen(pool_buf) + 1);
1245    item->type = type;
1246    item->mtime = time(NULL);
1247    strcpy(item->msg, pool_buf);
1248    /* If no jcr or dequeuing send to daemon to avoid recursion */
1249    if (!jcr || jcr->dequeuing) {
1250       /* jcr==NULL => daemon message, safe to send now */
1251       Jmsg(NULL, item->type, item->mtime, "%s", item->msg);
1252       free(item);
1253    } else {
1254       /* Queue message for later sending */
1255       P(msg_queue_mutex);
1256       jcr->msg_queue->append(item);
1257       V(msg_queue_mutex);
1258 //    Dmsg1(000, "queue item=%lu\n", (long unsigned)item);
1259    }
1260    free_memory(pool_buf);
1261 }
1262
1263 /*
1264  * Dequeue messages
1265  */
1266 void dequeue_messages(JCR *jcr)
1267 {
1268    MQUEUE_ITEM *item;
1269    P(msg_queue_mutex);
1270    jcr->dequeuing = true;
1271    foreach_dlist(item, jcr->msg_queue) {
1272 //    Dmsg1(000, "dequeue item=%lu\n", (long unsigned)item);
1273       Jmsg(jcr, item->type, item->mtime, "%s", item->msg);
1274    }
1275    jcr->msg_queue->destroy();
1276    jcr->dequeuing = false;
1277    V(msg_queue_mutex);
1278 }
1279
1280
1281 /*
1282  * If we come here, prefix the message with the file:line-number,
1283  *  then pass it on to the normal Qmsg routine.
1284  */
1285 void q_msg(const char *file, int line, JCR *jcr, int type, time_t mtime, const char *fmt,...)
1286 {
1287    va_list   arg_ptr;
1288    int i, len, maxlen;
1289    POOLMEM *pool_buf;
1290
1291    pool_buf = get_pool_memory(PM_EMSG);
1292    i = Mmsg(pool_buf, "%s:%d ", file, line);
1293
1294    for (;;) {
1295       maxlen = sizeof_pool_memory(pool_buf) - i - 1;
1296       va_start(arg_ptr, fmt);
1297       len = bvsnprintf(pool_buf+i, maxlen, fmt, arg_ptr);
1298       va_end(arg_ptr);
1299       if (len < 0 || len >= (maxlen-5)) {
1300          pool_buf = realloc_pool_memory(pool_buf, maxlen + i + maxlen/2);
1301          continue;
1302       }
1303       break;
1304    }
1305
1306    Qmsg(jcr, type, mtime, "%s", pool_buf);
1307    free_memory(pool_buf);
1308 }