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
 343 /*
 344  * Create a unique filename for the mail command
 345  */
 346 static void make_unique_mail_filename(JCR *jcr, POOLMEM **name, DEST *d)
 347 {
 348    if (jcr) {
 349       Mmsg(name, "%s/%s.mail.%s.%d", working_directory, my_name,
 350                  jcr->Job, (int)(long)d);
 351    } else {
 352       Mmsg(name, "%s/%s.mail.%s.%d", working_directory, my_name,
 353                  my_name, (int)(long)d);
 354    }
 355    Dmsg1(200, "mailname=%s\n", *name);
 356 }
 357
 358 /*
 359  * Open a mail pipe
 360  */
 361 static BPIPE *open_mail_pipe(JCR *jcr, POOLMEM **cmd, DEST *d)
 362 {
 363    BPIPE *bpipe;
 364
 365    if (d->mail_cmd && jcr) {
 366       *cmd = edit_job_codes(jcr, *cmd, d->mail_cmd, d->where);
 367    } else {
 368       Mmsg(cmd, "mail -s \"Bacula Message\" %s", d->where);
 369    }
 370    fflush(stdout);
 371
 372    if (!(bpipe = open_bpipe(*cmd, 120, "rw"))) {
 373       Jmsg(jcr, M_ERROR, 0, "open mail pipe %s failed: ERR=%s\n",
 374          *cmd, strerror(errno));
 375    }
 376    return bpipe;
 377 }
 378
 379 /*
 380  * Close the messages for this Messages resource, which means to close
 381  *  any open files, and dispatch any pending email messages.
 382  */
 383 void close_msg(JCR *jcr)
 384 {
 385    MSGS *msgs;
 386    DEST *d;
 387    BPIPE *bpipe;
 388    POOLMEM *cmd, *line;
 389    int len, stat;
 390
 391    Dmsg1(050, "Close_msg jcr=0x%x\n", jcr);
 392
 393    if (jcr == NULL) {                /* NULL -> global chain */
 394       msgs = daemon_msgs;
 395    } else {
 396       msgs = jcr->jcr_msgs;
 397       jcr->jcr_msgs = NULL;
 398    }
 399    if (msgs == NULL) {
 400       return;
 401    }
 402    Dmsg1(150, "===Begin close msg resource at 0x%x\n", msgs);
 403    cmd = get_pool_memory(PM_MESSAGE);
 404    for (d=msgs->dest_chain; d; ) {
 405       if (d->fd) {
 406          switch (d->dest_code) {
 407          case MD_FILE:
 408          case MD_APPEND:
 409             if (d->fd) {
 410                fclose(d->fd);            /* close open file descriptor */
 411             }
 412             break;
 413          case MD_MAIL:
 414          case MD_MAIL_ON_ERROR:
 415             Dmsg0(150, "Got MD_MAIL or MD_MAIL_ON_ERROR\n");
 416             if (!d->fd) {
 417                break;
 418             }
 419             if (d->dest_code == MD_MAIL_ON_ERROR && jcr &&
 420                 jcr->JobStatus == JS_Terminated) {
 421                goto rem_temp_file;
 422             }
 423
 424             if (!(bpipe=open_mail_pipe(jcr, &cmd, d))) {
 425                Pmsg0(000, "open mail pipe failed.\n");
 426                goto rem_temp_file;
 427             }
 428             Dmsg0(150, "Opened mail pipe\n");
 429             len = d->max_len+10;
 430             line = get_memory(len);
 431             rewind(d->fd);
 432             while (fgets(mp_chr(line), len, d->fd)) {
 433                fputs(line, bpipe->wfd);
 434             }
 435             if (!close_wpipe(bpipe)) {       /* close write pipe sending mail */
 436                Pmsg1(000, "close error: ERR=%s\n", strerror(errno));
 437             }
 438
 439             /*
 440              * Since we are closing all messages, before "recursing"
 441              * make sure we are not closing the daemon messages, otherwise
 442              * kaboom.
 443              */
 444             if (msgs != daemon_msgs) {
 445                /* read what mail prog returned -- should be nothing */
 446                while (fgets(mp_chr(line), len, bpipe->rfd)) {
 447                   Jmsg1(jcr, M_INFO, 0, _("Mail prog: %s"), line);
 448                }
 449             }
 450
 451             stat = close_bpipe(bpipe);
 452             if (stat != 0 && msgs != daemon_msgs) {
 453                Dmsg1(150, "Calling emsg. CMD=%s\n", cmd);
 454                Jmsg3(jcr, M_ERROR, 0, _("Mail program terminated in error. stat=%d\n"
 455                                         "CMD=%s\n"
 456                                         "ERR=%s\n"), stat, cmd, strerror(stat));
 457             }
 458             free_memory(line);
 459 rem_temp_file:
 460             /* Remove temp file */
 461             fclose(d->fd);
 462             unlink(mp_chr(d->mail_filename));
 463             free_pool_memory(d->mail_filename);
 464             d->mail_filename = NULL;
 465             Dmsg0(150, "end mail or mail on error\n");
 466             break;
 467          default:
 468             break;
 469          }
 470          d->fd = NULL;
 471       }
 472       d = d->next;                    /* point to next buffer */
 473    }
 474    free_pool_memory(cmd);
 475    Dmsg0(150, "Done walking message chain.\n");
 476    if (jcr) {
 477       free_msgs_res(msgs);
 478       msgs = NULL;
 479    }
 480    Dmsg0(150, "===End close msg resource\n");
 481 }
 482
 483 /*
 484  * Free memory associated with Messages resource
 485  */
 486 void free_msgs_res(MSGS *msgs)
 487 {
 488    DEST *d, *old;
 489
 490    /* Walk down the message chain releasing allocated buffers */
 491    for (d=msgs->dest_chain; d; ) {
 492       if (d->where) {
 493          free(d->where);
 494       }
 495       if (d->mail_cmd) {
 496          free(d->mail_cmd);
 497       }
 498       old = d;                        /* save pointer to release */
 499       d = d->next;                    /* point to next buffer */
 500       free(old);                      /* free the destination item */
 501    }
 502    msgs->dest_chain = NULL;
 503    free(msgs);                        /* free the head */
 504 }
 505
 506
 507 /*
 508  * Terminate the message handler for good.
 509  * Release the global destination chain.
 510  *
 511  * Also, clean up a few other items (cons, exepath). Note,
 512  *   these really should be done elsewhere.
 513  */
 514 void term_msg()
 515 {
 516    Dmsg0(100, "Enter term_msg\n");
 517    close_msg(NULL);                   /* close global chain */
 518    free_msgs_res(daemon_msgs);        /* free the resources */
 519    daemon_msgs = NULL;
 520    if (con_fd) {
 521       fflush(con_fd);
 522       fclose(con_fd);
 523       con_fd = NULL;
 524    }
 525    if (exepath) {
 526       free(exepath);
 527       exepath = NULL;
 528    }
 529    if (exename) {
 530       free(exename);
 531       exename = NULL;
 532    }
 533    if (trace_fd) {
 534       fclose(trace_fd);
 535       trace_fd = NULL;
 536    }
 537    term_last_jobs_list();
 538 }
 539
 540
 541
 542 /*
 543  * Handle sending the message to the appropriate place
 544  */
 545 void dispatch_message(JCR *jcr, int type, int level, char *msg)
 546 {
 547     DEST *d;
 548     char dt[MAX_TIME_LENGTH];
 549     POOLMEM *mcmd;
 550     int len;
 551     MSGS *msgs;
 552     BPIPE *bpipe;
 553
 554     Dmsg2(800, "Enter dispatch_msg type=%d msg=%s\n", type, msg);
 555
 556     if (type == M_ABORT || type == M_ERROR_TERM) {
 557        fputs(msg, stdout);         /* print this here to INSURE that it is printed */
 558        fflush(stdout);
 559 #if defined(HAVE_CYGWIN) || defined(HAVE_WIN32)
 560        MessageBox(NULL, msg, "Bacula", MB_OK);
 561 #endif
 562     }
 563
 564     /* Now figure out where to send the message */
 565     msgs = NULL;
 566     if (jcr) {
 567        msgs = jcr->jcr_msgs;
 568     }
 569     if (msgs == NULL) {
 570        msgs = daemon_msgs;
 571     }
 572     for (d=msgs->dest_chain; d; d=d->next) {
 573        if (bit_is_set(type, d->msg_types)) {
 574           switch (d->dest_code) {
 575              case MD_CONSOLE:
 576                 Dmsg1(800, "CONSOLE for following msg: %s", msg);
 577                 if (!con_fd) {
 578                    con_fd = fopen(con_fname, "a+");
 579                    Dmsg0(800, "Console file not open.\n");
 580                 }
 581                 if (con_fd) {
 582                    Pw(con_lock);      /* get write lock on console message file */
 583                    errno = 0;
 584                    bstrftime(dt, sizeof(dt), time(NULL));
 585                    len = strlen(dt);
 586                    dt[len++] = ' ';
 587                    fwrite(dt, len, 1, con_fd);
 588                    len = strlen(msg);
 589                    if (len > 0) {
 590                       fwrite(msg, len, 1, con_fd);
 591                       if (msg[len-1] != '\n') {
 592                          fwrite("\n", 2, 1, con_fd);
 593                       }
 594                    } else {
 595                       fwrite("\n", 2, 1, con_fd);
 596                    }
 597                    fflush(con_fd);
 598                    console_msg_pending = TRUE;
 599                    Vw(con_lock);
 600                 }
 601                 break;
 602              case MD_SYSLOG:
 603                 Dmsg1(800, "SYSLOG for collowing msg: %s\n", msg);
 604                 /*
 605                  * We really should do an openlog() here.
 606                  */
 607                 syslog(LOG_DAEMON|LOG_ERR, "%s", msg);
 608                 break;
 609              case MD_OPERATOR:
 610                 Dmsg1(800, "OPERATOR for collowing msg: %s\n", msg);
 611                 mcmd = get_pool_memory(PM_MESSAGE);
 612                 if ((bpipe=open_mail_pipe(jcr, &mcmd, d))) {
 613                    int stat;
 614                    fputs(msg, bpipe->wfd);
 615                    /* Messages to the operator go one at a time */
 616                    stat = close_bpipe(bpipe);
 617                    if (stat != 0) {
 618                       Jmsg2(jcr, M_ERROR, 0, _("Operator mail program terminated in error.\n"
 619                             "CMD=%s\n"
 620                             "ERR=%s\n"), mcmd, strerror(stat));
 621                    }
 622                 }
 623                 free_pool_memory(mcmd);
 624                 break;
 625              case MD_MAIL:
 626              case MD_MAIL_ON_ERROR:
 627                 Dmsg1(800, "MAIL for following msg: %s", msg);
 628                 if (!d->fd) {
 629                    POOLMEM *name = get_pool_memory(PM_MESSAGE);
 630                    make_unique_mail_filename(jcr, &mp_chr(name), d);
 631                    d->fd = fopen(mp_chr(name), "w+");
 632                    if (!d->fd) {
 633                       d->fd = stdout;
 634                       Jmsg2(jcr, M_ERROR, 0, "fopen %s failed: ERR=%s\n", name, strerror(errno));
 635                       d->fd = NULL;
 636                       free_pool_memory(name);
 637                       break;
 638                    }
 639                    d->mail_filename = name;
 640                 }
 641                 len = strlen(msg);
 642                 if (len > d->max_len) {
 643                    d->max_len = len;      /* keep max line length */
 644                 }
 645                 fputs(msg, d->fd);
 646                 break;
 647              case MD_FILE:
 648                 Dmsg1(800, "FILE for following msg: %s", msg);
 649                 if (!d->fd) {
 650                    d->fd = fopen(d->where, "w+");
 651                    if (!d->fd) {
 652                       d->fd = stdout;
 653                       Jmsg2(jcr, M_ERROR, 0, "fopen %s failed: ERR=%s\n", d->where, strerror(errno));
 654                       d->fd = NULL;
 655                       break;
 656                    }
 657                 }
 658                 fputs(msg, d->fd);
 659                 break;
 660              case MD_APPEND:
 661                 Dmsg1(800, "APPEND for following msg: %s", msg);
 662                 if (!d->fd) {
 663                    d->fd = fopen(d->where, "a");
 664                    if (!d->fd) {
 665                       d->fd = stdout;
 666                       Jmsg2(jcr, M_ERROR, 0, "fopen %s failed: ERR=%s\n", d->where, strerror(errno));
 667                       d->fd = NULL;
 668                       break;
 669                    }
 670                 }
 671                 fputs(msg, d->fd);
 672                 break;
 673              case MD_DIRECTOR:
 674                 Dmsg1(800, "DIRECTOR for following msg: %s", msg);
 675                 if (jcr && jcr->dir_bsock && !jcr->dir_bsock->errors) {
 676                    bnet_fsend(jcr->dir_bsock, "Jmsg Job=%s type=%d level=%d %s",
 677                       jcr->Job, type, level, msg);
 678                 }
 679                 break;
 680              case MD_STDOUT:
 681                 Dmsg1(800, "STDOUT for following msg: %s", msg);
 682                 if (type != M_ABORT && type != M_ERROR_TERM) { /* already printed */
 683                    fputs(msg, stdout);
 684                 }
 685                 break;
 686              case MD_STDERR:
 687                 Dmsg1(800, "STDERR for following msg: %s", msg);
 688                 fputs(msg, stderr);
 689                 break;
 690              default:
 691                 break;
 692           }
 693        }
 694     }
 695 }
 696
 697
 698 /*********************************************************************
 699  *
 700  *  This subroutine prints a debug message if the level number
 701  *  is less than or equal the debug_level. File and line numbers
 702  *  are included for more detail if desired, but not currently
 703  *  printed.
 704  *
 705  *  If the level is negative, the details of file and line number
 706  *  are not printed.
 707  */
 708 void
 709 d_msg(const char *file, int line, int level, const char *fmt,...)
 710 {
 711     char      buf[5000];
 712     int       len;
 713     va_list   arg_ptr;
 714     int       details = TRUE;
 715
 716     if (level < 0) {
 717        details = FALSE;
 718        level = -level;
 719     }
 720
 721     if (level <= debug_level) {
 722 #ifdef FULL_LOCATION
 723        if (details) {
 724           /* visual studio passes the whole path to the file as well
 725            * which makes for very long lines
 726            */
 727           char *f = strrchr(file, '\\');
 728           if (f) file = f + 1;
 729           len = bsnprintf(buf, sizeof(buf), "%s: %s:%d ", my_name, file, line);
 730        } else {
 731           len = 0;
 732        }
 733 #else
 734        len = 0;
 735 #endif
 736        va_start(arg_ptr, fmt);
 737        bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
 738        va_end(arg_ptr);
 739
 740        /*
 741         * Used the "trace on" command in the console to turn on
 742         *  output to the trace file.  "trace off" will close the file.
 743         */
 744        if (trace) {
 745           if (!trace_fd) {
 746              bsnprintf(buf, sizeof(buf), "%s/bacula.trace", working_directory ? working_directory : ".");
 747              trace_fd = fopen(buf, "a+");
 748           }
 749           if (trace_fd) {
 750              fputs(buf, trace_fd);
 751              fflush(trace_fd);
 752           }
 753        } else {   /* not tracing */
 754           fputs(buf, stdout);
 755        }
 756     }
 757 }
 758
 759 /*
 760  * Set trace flag on/off. If argument is negative, there is no change
 761  */
 762 void set_trace(int trace_flag)
 763 {
 764    if (trace_flag < 0) {
 765       return;
 766    } else if (trace_flag > 0) {
 767       trace = true;
 768    } else {
 769       trace = false;
 770    }
 771    if (!trace && trace_fd) {
 772       FILE *ltrace_fd = trace_fd;
 773       trace_fd = NULL;
 774       bmicrosleep(0, 100000);         /* yield to prevent seg faults */
 775       fclose(ltrace_fd);
 776    }
 777 }
 778
 779 /*********************************************************************
 780  *
 781  *  This subroutine prints a message regardless of the debug level
 782  *
 783  *  If the level is negative, the details of file and line number
 784  *  are not printed.
 785  */
 786 void
 787 p_msg(const char *file, int line, int level, const char *fmt,...)
 788 {
 789     char      buf[5000];
 790     int       len;
 791     va_list   arg_ptr;
 792
 793 #ifdef FULL_LOCATION
 794     if (level >= 0) {
 795        len = bsnprintf(buf, sizeof(buf), "%s: %s:%d ", my_name, file, line);
 796     } else {
 797        len = 0;
 798     }
 799 #else
 800     len = 0;
 801 #endif
 802     va_start(arg_ptr, fmt);
 803     bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
 804     va_end(arg_ptr);
 805     fputs(buf, stdout);
 806 }
 807
 808
 809 /*********************************************************************
 810  *
 811  *  subroutine writes a debug message to the trace file if the level number
 812  *  is less than or equal the debug_level. File and line numbers
 813  *  are included for more detail if desired, but not currently
 814  *  printed.
 815  *
 816  *  If the level is negative, the details of file and line number
 817  *  are not printed.
 818  */
 819 void
 820 t_msg(const char *file, int line, int level, const char *fmt,...)
 821 {
 822     char      buf[5000];
 823     int       len;
 824     va_list   arg_ptr;
 825     int       details = TRUE;
 826
 827     if (level < 0) {
 828        details = FALSE;
 829        level = -level;
 830     }
 831
 832     if (level <= debug_level) {
 833        if (!trace_fd) {
 834           bsnprintf(buf, sizeof(buf), "%s/bacula.trace", working_directory);
 835           trace_fd = fopen(buf, "a+");
 836        }
 837
 838 #ifdef FULL_LOCATION
 839        if (details) {
 840           len = bsnprintf(buf, sizeof(buf), "%s: %s:%d ", my_name, file, line);
 841        } else {
 842           len = 0;
 843        }
 844 #else
 845        len = 0;
 846 #endif
 847        va_start(arg_ptr, fmt);
 848        bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
 849        va_end(arg_ptr);
 850        if (trace_fd != NULL) {
 851            fputs(buf, trace_fd);
 852            fflush(trace_fd);
 853        }
 854    }
 855 }
 856
 857
 858
 859 /* *********************************************************
 860  *
 861  * print an error message
 862  *
 863  */
 864 void
 865 e_msg(const char *file, int line, int type, int level, const char *fmt,...)
 866 {
 867     char     buf[5000];
 868     va_list   arg_ptr;
 869     int len;
 870
 871     /*
 872      * Check if we have a message destination defined.
 873      * We always report M_ABORT and M_ERROR_TERM
 874      */
 875     if (!daemon_msgs || ((type != M_ABORT && type != M_ERROR_TERM) &&
 876                          !bit_is_set(type, daemon_msgs->send_msg))) {
 877        return;                        /* no destination */
 878     }
 879     switch (type) {
 880     case M_ABORT:
 881        len = bsnprintf(buf, sizeof(buf), "%s: ABORTING due to ERROR in %s:%d\n",
 882                my_name, file, line);
 883        break;
 884     case M_ERROR_TERM:
 885        len = bsnprintf(buf, sizeof(buf), "%s: ERROR TERMINATION at %s:%d\n",
 886                my_name, file, line);
 887        break;
 888     case M_FATAL:
 889        if (level == -1)            /* skip details */
 890           len = bsnprintf(buf, sizeof(buf), "%s: Fatal Error because: ", my_name);
 891        else
 892           len = bsnprintf(buf, sizeof(buf), "%s: Fatal Error at %s:%d because:\n", my_name, file, line);
 893        break;
 894     case M_ERROR:
 895        if (level == -1)            /* skip details */
 896           len = bsnprintf(buf, sizeof(buf), "%s: ERROR: ", my_name);
 897        else
 898           len = bsnprintf(buf, sizeof(buf), "%s: ERROR in %s:%d ", my_name, file, line);
 899        break;
 900     case M_WARNING:
 901        len = bsnprintf(buf, sizeof(buf), "%s: Warning: ", my_name);
 902        break;
 903     case M_SECURITY:
 904        len = bsnprintf(buf, sizeof(buf), "%s: Security violation: ", my_name);
 905        break;
 906     default:
 907        len = bsnprintf(buf, sizeof(buf), "%s: ", my_name);
 908        break;
 909     }
 910
 911     va_start(arg_ptr, fmt);
 912     bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
 913     va_end(arg_ptr);
 914
 915     dispatch_message(NULL, type, level, buf);
 916
 917     if (type == M_ABORT) {
 918        char *p = 0;
 919        p[0] = 0;                      /* generate segmentation violation */
 920     }
 921     if (type == M_ERROR_TERM) {
 922        exit(1);
 923     }
 924 }
 925
 926 /* *********************************************************
 927  *
 928  * Generate a Job message
 929  *
 930  */
 931 void
 932 Jmsg(JCR *jcr, int type, int level, const char *fmt,...)
 933 {
 934     char     rbuf[5000];
 935     va_list   arg_ptr;
 936     int len;
 937     MSGS *msgs;
 938     const char *job;
 939
 940
 941     Dmsg1(800, "Enter Jmsg type=%d\n", type);
 942
 943     /* Special case for the console, which has a dir_bsock and JobId==0,
 944      *  in that case, we send the message directly back to the
 945      *  dir_bsock.
 946      */
 947     if (jcr && jcr->JobId == 0 && jcr->dir_bsock) {
 948        BSOCK *dir = jcr->dir_bsock;
 949        va_start(arg_ptr, fmt);
 950        dir->msglen = bvsnprintf(mp_chr(dir->msg), sizeof_pool_memory(dir->msg),
 951                                 fmt, arg_ptr);
 952        va_end(arg_ptr);
 953        bnet_send(jcr->dir_bsock);
 954        return;
 955     }
 956
 957     msgs = NULL;
 958     job = NULL;
 959     if (jcr) {
 960        msgs = jcr->jcr_msgs;
 961        job = jcr->Job;
 962     }
 963     if (!msgs) {
 964        msgs = daemon_msgs;            /* if no jcr, we use daemon handler */
 965     }
 966     if (!job) {
 967        job = "";                      /* Set null job name if none */
 968     }
 969
 970     /*
 971      * Check if we have a message destination defined.
 972      * We always report M_ABORT and M_ERROR_TERM
 973      */
 974     if (msgs && (type != M_ABORT && type != M_ERROR_TERM) &&
 975          !bit_is_set(type, msgs->send_msg)) {
 976        return;                        /* no destination */
 977     }
 978     switch (type) {
 979     case M_ABORT:
 980        len = bsnprintf(rbuf, sizeof(rbuf), "%s ABORTING due to ERROR\n", my_name);
 981        break;
 982     case M_ERROR_TERM:
 983        len = bsnprintf(rbuf, sizeof(rbuf), "%s ERROR TERMINATION\n", my_name);
 984        break;
 985     case M_FATAL:
 986        len = bsnprintf(rbuf, sizeof(rbuf), "%s: %s Fatal error: ", my_name, job);
 987        if (jcr) {
 988           set_jcr_job_status(jcr, JS_FatalError);
 989        }
 990        break;
 991     case M_ERROR:
 992        len = bsnprintf(rbuf, sizeof(rbuf), "%s: %s Error: ", my_name, job);
 993        if (jcr) {
 994           jcr->Errors++;
 995        }
 996        break;
 997     case M_WARNING:
 998        len = bsnprintf(rbuf, sizeof(rbuf), "%s: %s Warning: ", my_name, job);
 999        break;
1000     case M_SECURITY:
1001        len = bsnprintf(rbuf, sizeof(rbuf), "%s: %s Security violation: ", my_name, job);
1002        break;
1003     default:
1004        len = bsnprintf(rbuf, sizeof(rbuf), "%s: ", my_name);
1005        break;
1006     }
1007
1008     va_start(arg_ptr, fmt);
1009     bvsnprintf(rbuf+len,  sizeof(rbuf)-len, fmt, arg_ptr);
1010     va_end(arg_ptr);
1011
1012     dispatch_message(jcr, type, level, rbuf);
1013
1014     if (type == M_ABORT){
1015        char *p = 0;
1016        p[0] = 0;                      /* generate segmentation violation */
1017     }
1018     if (type == M_ERROR_TERM) {
1019        exit(1);
1020     }
1021 }
1022
1023 /*
1024  * If we come here, prefix the message with the file:line-number,
1025  *  then pass it on to the normal Jmsg routine.
1026  */
1027 void j_msg(const char *file, int line, JCR *jcr, int type, int level, const char *fmt,...)
1028 {
1029    va_list   arg_ptr;
1030    int i, len, maxlen;
1031    POOLMEM *pool_buf;
1032
1033    pool_buf = get_pool_memory(PM_EMSG);
1034    i = Mmsg(&pool_buf, "%s:%d ", file, line);
1035
1036 again:
1037    maxlen = sizeof_pool_memory(pool_buf) - i - 1;
1038    va_start(arg_ptr, fmt);
1039    len = bvsnprintf(pool_buf+i, maxlen, fmt, arg_ptr);
1040    va_end(arg_ptr);
1041    if (len < 0 || len >= maxlen) {
1042       pool_buf = realloc_pool_memory(pool_buf, maxlen + i + maxlen/2);
1043       goto again;
1044    }
1045
1046    Jmsg(jcr, type, level, "%s", pool_buf);
1047    free_memory(pool_buf);
1048 }
1049
1050
1051 /*
1052  * Edit a message into a Pool memory buffer, with file:lineno
1053  */
1054 int m_msg(const char *file, int line, POOLMEM **pool_buf, const char *fmt, ...)
1055 {
1056    va_list   arg_ptr;
1057    int i, len, maxlen;
1058
1059    i = sprintf(mp_chr(*pool_buf), "%s:%d ", file, line);
1060
1061 again:
1062    maxlen = sizeof_pool_memory(*pool_buf) - i - 1;
1063    va_start(arg_ptr, fmt);
1064    len = bvsnprintf(*pool_buf+i, maxlen, fmt, arg_ptr);
1065    va_end(arg_ptr);
1066    if (len < 0 || len >= maxlen) {
1067       *pool_buf = realloc_pool_memory(*pool_buf, maxlen + i + maxlen/2);
1068       goto again;
1069    }
1070    return len;
1071 }
1072
1073 /*
1074  * Edit a message into a Pool Memory buffer NO file:lineno
1075  *  Returns: string length of what was edited.
1076  */
1077 int Mmsg(POOLMEM **pool_buf, const char *fmt, ...)
1078 {
1079    va_list   arg_ptr;
1080    int len, maxlen;
1081
1082 again:
1083    maxlen = sizeof_pool_memory(*pool_buf) - 1;
1084    va_start(arg_ptr, fmt);
1085    len = bvsnprintf(*pool_buf, maxlen, fmt, arg_ptr);
1086    va_end(arg_ptr);
1087    if (len < 0 || len >= maxlen) {
1088       *pool_buf = realloc_pool_memory(*pool_buf, maxlen + maxlen/2);
1089       goto again;
1090    }
1091    return len;
1092 }
1093
1094 static pthread_mutex_t msg_queue_mutex = PTHREAD_MUTEX_INITIALIZER;
1095
1096 /*
1097  * We queue messages rather than print them directly. This
1098  *  is generally used in low level routines (msg handler, bnet)
1099  *  to prevent recursion.
1100  */
1101 void Qmsg(JCR *jcr, int type, int level, const char *fmt,...)
1102 {
1103    va_list   arg_ptr;
1104    int len, maxlen;
1105    POOLMEM *pool_buf;
1106    MQUEUE_ITEM *item;
1107
1108    if (jcr->dequeuing) {              /* do not allow recursion */
1109       return;
1110    }
1111    pool_buf = get_pool_memory(PM_EMSG);
1112
1113 again:
1114    maxlen = sizeof_pool_memory(pool_buf) - 1;
1115    va_start(arg_ptr, fmt);
1116    len = bvsnprintf(pool_buf, maxlen, fmt, arg_ptr);
1117    va_end(arg_ptr);
1118    if (len < 0 || len >= maxlen) {
1119       pool_buf = realloc_pool_memory(pool_buf, maxlen + maxlen/2);
1120       goto again;
1121    }
1122    item = (MQUEUE_ITEM *)malloc(sizeof(MQUEUE_ITEM) + strlen(pool_buf) + 1);
1123    item->type = type;
1124    item->level = level;
1125    strcpy(item->msg, pool_buf);
1126    P(msg_queue_mutex);
1127    jcr->msg_queue->append(item);
1128    V(msg_queue_mutex);
1129    free_memory(pool_buf);
1130 }
1131
1132 /*
1133  * Dequeue messages
1134  */
1135 void dequeue_messages(JCR *jcr)
1136 {
1137    MQUEUE_ITEM *item;
1138    P(msg_queue_mutex);
1139    jcr->dequeuing = true;
1140    foreach_dlist(item, jcr->msg_queue) {
1141       Jmsg(jcr, item->type, item->level, "%s", item->msg);
1142    }
1143    jcr->msg_queue->destroy();
1144    jcr->dequeuing = false;
1145    V(msg_queue_mutex);
1146 }
1147
1148
1149 /*
1150  * If we come here, prefix the message with the file:line-number,
1151  *  then pass it on to the normal Qmsg routine.
1152  */
1153 void q_msg(const char *file, int line, JCR *jcr, int type, int level, const char *fmt,...)
1154 {
1155    va_list   arg_ptr;
1156    int i, len, maxlen;
1157    POOLMEM *pool_buf;
1158
1159    pool_buf = get_pool_memory(PM_EMSG);
1160    i = Mmsg(&pool_buf, "%s:%d ", file, line);
1161
1162 again:
1163    maxlen = sizeof_pool_memory(pool_buf) - i - 1;
1164    va_start(arg_ptr, fmt);
1165    len = bvsnprintf(pool_buf+i, maxlen, fmt, arg_ptr);
1166    va_end(arg_ptr);
1167    if (len < 0 || len >= maxlen) {
1168       pool_buf = realloc_pool_memory(pool_buf, maxlen + i + maxlen/2);
1169       goto again;
1170    }
1171
1172    Qmsg(jcr, type, level, "%s", pool_buf);
1173    free_memory(pool_buf);
1174 }