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