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