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