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