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