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                Jmsg2(jcr, M_ERROR, 0, _("Mail program terminated in error. stat=%d\n"
 481                                         "CMD=%s\n"), stat, cmd);
 482             }
 483             free_memory(line);
 484 rem_temp_file:
 485             /* Remove temp file */
 486             fclose(d->fd);
 487             unlink(mp_chr(d->mail_filename));
 488             free_pool_memory(d->mail_filename);
 489             d->mail_filename = NULL;
 490             Dmsg0(150, "end mail or mail on error\n");
 491             break;
 492          default:
 493             break;
 494          }
 495          d->fd = NULL;
 496       }
 497       d = d->next;                    /* point to next buffer */
 498    }
 499    free_pool_memory(cmd);
 500    Dmsg0(150, "Done walking message chain.\n");
 501    if (jcr) {
 502       free_msgs_res(msgs);
 503       msgs = NULL;
 504    }
 505    Dmsg0(150, "===End close msg resource\n");
 506 }
 507
 508 /*
 509  * Free memory associated with Messages resource
 510  */
 511 void free_msgs_res(MSGS *msgs)
 512 {
 513    DEST *d, *old;
 514
 515    /* Walk down the message chain releasing allocated buffers */
 516    for (d=msgs->dest_chain; d; ) {
 517       if (d->where) {
 518          free(d->where);
 519       }
 520       if (d->mail_cmd) {
 521          free(d->mail_cmd);
 522       }
 523       old = d;                        /* save pointer to release */
 524       d = d->next;                    /* point to next buffer */
 525       free(old);                      /* free the destination item */
 526    }
 527    msgs->dest_chain = NULL;
 528    free(msgs);                        /* free the head */
 529 }
 530
 531
 532 /*
 533  * Terminate the message handler for good.
 534  * Release the global destination chain.
 535  *
 536  * Also, clean up a few other items (cons, exepath). Note,
 537  *   these really should be done elsewhere.
 538  */
 539 void term_msg()
 540 {
 541    Dmsg0(100, "Enter term_msg\n");
 542    close_msg(NULL);                   /* close global chain */
 543    free_msgs_res(daemon_msgs);        /* free the resources */
 544    daemon_msgs = NULL;
 545    if (con_fd) {
 546       fflush(con_fd);
 547       fclose(con_fd);
 548       con_fd = NULL;
 549    }
 550    if (exepath) {
 551       free(exepath);
 552       exepath = NULL;
 553    }
 554    if (exename) {
 555       free(exename);
 556       exename = NULL;
 557    }
 558    if (trace_fd) {
 559       fclose(trace_fd);
 560       trace_fd = NULL;
 561    }
 562    term_last_jobs_list();
 563 }
 564
 565
 566
 567 /*
 568  * Handle sending the message to the appropriate place
 569  */
 570 void dispatch_message(JCR *jcr, int type, int level, char *msg)
 571 {
 572     DEST *d;
 573     char dt[MAX_TIME_LENGTH];
 574     POOLMEM *mcmd;
 575     int len;
 576     MSGS *msgs;
 577     BPIPE *bpipe;
 578
 579     Dmsg2(800, "Enter dispatch_msg type=%d msg=%s\n", type, msg);
 580
 581     if (type == M_ABORT || type == M_ERROR_TERM) {
 582        fputs(msg, stdout);         /* print this here to INSURE that it is printed */
 583     }
 584
 585     /* Now figure out where to send the message */
 586     msgs = NULL;
 587     if (jcr) {
 588        msgs = jcr->jcr_msgs;
 589     }
 590     if (msgs == NULL) {
 591        msgs = daemon_msgs;
 592     }
 593     for (d=msgs->dest_chain; d; d=d->next) {
 594        if (bit_is_set(type, d->msg_types)) {
 595           switch (d->dest_code) {
 596              case MD_CONSOLE:
 597                 Dmsg1(800, "CONSOLE for following msg: %s", msg);
 598                 if (!con_fd) {
 599                    con_fd = fopen(con_fname, "a+");
 600                    Dmsg0(800, "Console file not open.\n");
 601                 }
 602                 if (con_fd) {
 603                    Pw(con_lock);      /* get write lock on console message file */
 604                    errno = 0;
 605                    bstrftime(dt, sizeof(dt), time(NULL));
 606                    len = strlen(dt);
 607                    dt[len++] = ' ';
 608                    fwrite(dt, len, 1, con_fd);
 609                    len = strlen(msg);
 610                    if (len > 0) {
 611                       fwrite(msg, len, 1, con_fd);
 612                       if (msg[len-1] != '\n') {
 613                          fwrite("\n", 2, 1, con_fd);
 614                       }
 615                    } else {
 616                       fwrite("\n", 2, 1, con_fd);
 617                    }
 618                    fflush(con_fd);
 619                    console_msg_pending = TRUE;
 620                    Vw(con_lock);
 621                 }
 622                 break;
 623              case MD_SYSLOG:
 624                 Dmsg1(800, "SYSLOG for collowing msg: %s\n", msg);
 625                 /*
 626                  * We really should do an openlog() here.
 627                  */
 628                 syslog(LOG_DAEMON|LOG_ERR, "%s", msg);
 629                 break;
 630              case MD_OPERATOR:
 631                 Dmsg1(800, "OPERATOR for collowing msg: %s\n", msg);
 632                 mcmd = get_pool_memory(PM_MESSAGE);
 633                 if ((bpipe=open_mail_pipe(jcr, &mcmd, d))) {
 634                    int stat;
 635                    fputs(msg, bpipe->wfd);
 636                    /* Messages to the operator go one at a time */
 637                    stat = close_bpipe(bpipe);
 638                    if (stat != 0) {
 639                       Emsg1(M_ERROR, 0, _("Operator mail program terminated in error.\nCMD=%s\n"),
 640                          mcmd);
 641                    }
 642                 }
 643                 free_pool_memory(mcmd);
 644                 break;
 645              case MD_MAIL:
 646              case MD_MAIL_ON_ERROR:
 647                 Dmsg1(800, "MAIL for following msg: %s", msg);
 648                 if (!d->fd) {
 649                    POOLMEM *name = get_pool_memory(PM_MESSAGE);
 650                    make_unique_mail_filename(jcr, &mp_chr(name), d);
 651                    d->fd = fopen(mp_chr(name), "w+");
 652                    if (!d->fd) {
 653                       d->fd = stdout;
 654                       Emsg2(M_ERROR, 0, "fopen %s failed: ERR=%s\n", name, strerror(errno));
 655                       d->fd = NULL;
 656                       free_pool_memory(name);
 657                       break;
 658                    }
 659                    d->mail_filename = name;
 660                 }
 661                 len = strlen(msg);
 662                 if (len > d->max_len) {
 663                    d->max_len = len;      /* keep max line length */
 664                 }
 665                 fputs(msg, d->fd);
 666                 break;
 667              case MD_FILE:
 668                 Dmsg1(800, "FILE for following msg: %s", msg);
 669                 if (!d->fd) {
 670                    d->fd = fopen(d->where, "w+");
 671                    if (!d->fd) {
 672                       d->fd = stdout;
 673                       Emsg2(M_ERROR, 0, "fopen %s failed: ERR=%s\n", d->where, strerror(errno));
 674                       d->fd = NULL;
 675                       break;
 676                    }
 677                 }
 678                 fputs(msg, d->fd);
 679                 break;
 680              case MD_APPEND:
 681                 Dmsg1(800, "APPEND for following msg: %s", msg);
 682                 if (!d->fd) {
 683                    d->fd = fopen(d->where, "a");
 684                    if (!d->fd) {
 685                       d->fd = stdout;
 686                       Emsg2(M_ERROR, 0, "fopen %s failed: ERR=%s\n", d->where, strerror(errno));
 687                       d->fd = NULL;
 688                       break;
 689                    }
 690                 }
 691                 fputs(msg, d->fd);
 692                 break;
 693              case MD_DIRECTOR:
 694                 Dmsg1(800, "DIRECTOR for following msg: %s", msg);
 695                 if (jcr && jcr->dir_bsock && !jcr->dir_bsock->errors) {
 696                    bnet_fsend(jcr->dir_bsock, "Jmsg Job=%s type=%d level=%d %s",
 697                       jcr->Job, type, level, msg);
 698                 }
 699                 break;
 700              case MD_STDOUT:
 701                 Dmsg1(800, "STDOUT for following msg: %s", msg);
 702                 if (type != M_ABORT && type != M_ERROR_TERM) { /* already printed */
 703                    fputs(msg, stdout);
 704                 }
 705                 break;
 706              case MD_STDERR:
 707                 Dmsg1(800, "STDERR for following msg: %s", msg);
 708                 fputs(msg, stderr);
 709                 break;
 710              default:
 711                 break;
 712           }
 713        }
 714     }
 715 }
 716
 717
 718 /*********************************************************************
 719  *
 720  *  This subroutine prints a debug message if the level number
 721  *  is less than or equal the debug_level. File and line numbers
 722  *  are included for more detail if desired, but not currently
 723  *  printed.
 724  *
 725  *  If the level is negative, the details of file and line number
 726  *  are not printed.
 727  */
 728 void
 729 d_msg(char *file, int line, int level, char *fmt,...)
 730 {
 731     char      buf[5000];
 732     int       len;
 733     va_list   arg_ptr;
 734     int       details = TRUE;
 735
 736     if (level < 0) {
 737        details = FALSE;
 738        level = -level;
 739     }
 740
 741     if (level <= debug_level) {
 742 #ifdef SEND_DMSG_TO_FILE
 743        if (!trace_fd) {
 744           bsnprintf(buf, sizeof(buf), "%s/bacula.trace", working_directory);
 745           trace_fd = fopen(buf, "a+");
 746           if (!trace_fd) {
 747              Emsg2(M_ABORT, 0, _("Cannot open %s: ERR=%s\n"),
 748                   buf, strerror(errno));
 749           }
 750        }
 751 #endif
 752 #ifdef FULL_LOCATION
 753        if (details) {
 754           len = sprintf(buf, "%s: %s:%d ", my_name, file, line);
 755        } else {
 756           len = 0;
 757        }
 758 #else
 759        len = 0;
 760 #endif
 761        va_start(arg_ptr, fmt);
 762        bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
 763        va_end(arg_ptr);
 764
 765 #ifdef SEND_DMSG_TO_FILE
 766        fputs(buf, trace_fd);
 767        fflush(trace_fd);
 768 #else
 769        fputs(buf, stdout);
 770 #endif
 771     }
 772 }
 773
 774
 775 /*********************************************************************
 776  *
 777  *  This subroutine prints a message regardless of the debug level
 778  *
 779  *  If the level is negative, the details of file and line number
 780  *  are not printed.
 781  */
 782 void
 783 p_msg(char *file, int line, int level, char *fmt,...)
 784 {
 785     char      buf[5000];
 786     int       len;
 787     va_list   arg_ptr;
 788
 789 #ifdef FULL_LOCATION
 790     if (level >= 0) {
 791        len = sprintf(buf, "%s: %s:%d ", my_name, file, line);
 792     } else {
 793        len = 0;
 794     }
 795 #else
 796     len = 0;
 797 #endif
 798     va_start(arg_ptr, fmt);
 799     bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
 800     va_end(arg_ptr);
 801     fputs(buf, stdout);
 802 }
 803
 804
 805 /*********************************************************************
 806  *
 807  *  subroutine writes a debug message to the trace file if the level number
 808  *  is less than or equal the debug_level. File and line numbers
 809  *  are included for more detail if desired, but not currently
 810  *  printed.
 811  *
 812  *  If the level is negative, the details of file and line number
 813  *  are not printed.
 814  */
 815 void
 816 t_msg(char *file, int line, int level, char *fmt,...)
 817 {
 818     char      buf[5000];
 819     int       len;
 820     va_list   arg_ptr;
 821     int       details = TRUE;
 822
 823     if (level < 0) {
 824        details = FALSE;
 825        level = -level;
 826     }
 827
 828     if (level <= debug_level) {
 829        if (!trace_fd) {
 830           bsnprintf(buf, sizeof(buf), "%s/bacula.trace", working_directory);
 831           trace_fd = fopen(buf, "a+");
 832           if (!trace_fd) {
 833              Emsg2(M_ABORT, 0, _("Cannot open %s: ERR=%s\n"),
 834                   buf, strerror(errno));
 835           }
 836        }
 837
 838 #ifdef FULL_LOCATION
 839        if (details) {
 840           len = sprintf(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
 851        fputs(buf, trace_fd);
 852        fflush(trace_fd);
 853     }
 854 }
 855
 856
 857
 858 /* *********************************************************
 859  *
 860  * print an error message
 861  *
 862  */
 863 void
 864 e_msg(char *file, int line, int type, int level, char *fmt,...)
 865 {
 866     char     buf[5000];
 867     va_list   arg_ptr;
 868     int len;
 869
 870     /*
 871      * Check if we have a message destination defined.
 872      * We always report M_ABORT and M_ERROR_TERM
 873      */
 874     if (!daemon_msgs || ((type != M_ABORT && type != M_ERROR_TERM) &&
 875                          !bit_is_set(type, daemon_msgs->send_msg))) {
 876        return;                        /* no destination */
 877     }
 878     switch (type) {
 879        case M_ABORT:
 880           len = sprintf(buf, "%s: ABORTING due to ERROR in %s:%d\n",
 881                   my_name, file, line);
 882           break;
 883        case M_ERROR_TERM:
 884           len = sprintf(buf, "%s: ERROR TERMINATION at %s:%d\n",
 885                   my_name, file, line);
 886           break;
 887        case M_FATAL:
 888           if (level == -1)            /* skip details */
 889              len = sprintf(buf, "%s: Fatal Error because: ", my_name);
 890           else
 891              len = sprintf(buf, "%s: Fatal Error at %s:%d because:\n", my_name, file, line);
 892           break;
 893        case M_ERROR:
 894           if (level == -1)            /* skip details */
 895              len = sprintf(buf, "%s: Error: ", my_name);
 896           else
 897              len = sprintf(buf, "%s: Error in %s:%d ", my_name, file, line);
 898           break;
 899        case M_WARNING:
 900           len = sprintf(buf, "%s: Warning: ", my_name);
 901           break;
 902        default:
 903           len = sprintf(buf, "%s: ", my_name);
 904           break;
 905     }
 906
 907     va_start(arg_ptr, fmt);
 908     bvsnprintf(buf+len, sizeof(buf)-len, (char *)fmt, arg_ptr);
 909     va_end(arg_ptr);
 910
 911     dispatch_message(NULL, type, level, buf);
 912
 913     if (type == M_ABORT) {
 914        char *p = 0;
 915        p[0] = 0;                      /* generate segmentation violation */
 916     }
 917     if (type == M_ERROR_TERM) {
 918        _exit(1);
 919     }
 920 }
 921
 922 /* *********************************************************
 923  *
 924  * Generate a Job message
 925  *
 926  */
 927 void
 928 Jmsg(JCR *jcr, int type, int level, char *fmt,...)
 929 {
 930     char     rbuf[5000];
 931     va_list   arg_ptr;
 932     int len;
 933     MSGS *msgs;
 934     char *job;
 935
 936
 937     Dmsg1(800, "Enter Jmsg type=%d\n", type);
 938
 939     /* Special case for the console, which has a dir_bsock and JobId==0,
 940      *  in that case, we send the message directly back to the
 941      *  dir_bsock.
 942      */
 943     if (jcr && jcr->JobId == 0 && jcr->dir_bsock) {
 944        BSOCK *dir = jcr->dir_bsock;
 945        va_start(arg_ptr, fmt);
 946        dir->msglen = bvsnprintf(mp_chr(dir->msg), sizeof_pool_memory(dir->msg),
 947                                 fmt, arg_ptr);
 948        va_end(arg_ptr);
 949        bnet_send(jcr->dir_bsock);
 950        return;
 951     }
 952
 953     msgs = NULL;
 954     job = NULL;
 955     if (jcr) {
 956        msgs = jcr->jcr_msgs;
 957        job = jcr->Job;
 958     }
 959     if (!msgs) {
 960        msgs = daemon_msgs;            /* if no jcr, we use daemon handler */
 961     }
 962     if (!job) {
 963        job = "";                      /* Set null job name if none */
 964     }
 965
 966     /*
 967      * Check if we have a message destination defined.
 968      * We always report M_ABORT and M_ERROR_TERM
 969      */
 970     if (msgs && (type != M_ABORT && type != M_ERROR_TERM) &&
 971          !bit_is_set(type, msgs->send_msg)) {
 972        return;                        /* no destination */
 973     }
 974     switch (type) {
 975     case M_ABORT:
 976        len = sprintf(rbuf, "%s ABORTING due to ERROR\n", my_name);
 977        break;
 978     case M_ERROR_TERM:
 979        len = sprintf(rbuf, "%s ERROR TERMINATION\n", my_name);
 980        break;
 981     case M_FATAL:
 982        len = sprintf(rbuf, "%s: %s Fatal error: ", my_name, job);
 983        if (jcr) {
 984           set_jcr_job_status(jcr, JS_FatalError);
 985        }
 986        break;
 987     case M_ERROR:
 988        len = sprintf(rbuf, "%s: %s Error: ", my_name, job);
 989        if (jcr) {
 990           jcr->Errors++;
 991        }
 992        break;
 993     case M_WARNING:
 994        len = sprintf(rbuf, "%s: %s Warning: ", my_name, job);
 995        break;
 996     default:
 997        len = sprintf(rbuf, "%s: ", my_name);
 998        break;
 999     }
1000
1001     va_start(arg_ptr, fmt);
1002     bvsnprintf(rbuf+len,  sizeof(rbuf)-len, fmt, arg_ptr);
1003     va_end(arg_ptr);
1004
1005     dispatch_message(jcr, type, level, rbuf);
1006
1007     if (type == M_ABORT){
1008        char *p = 0;
1009        p[0] = 0;                      /* generate segmentation violation */
1010     }
1011     if (type == M_ERROR_TERM) {
1012        _exit(1);
1013     }
1014 }
1015
1016 /*
1017  * Edit a message into a Pool memory buffer, with file:lineno
1018  */
1019 int m_msg(char *file, int line, POOLMEM **pool_buf, char *fmt, ...)
1020 {
1021    va_list   arg_ptr;
1022    int i, len, maxlen;
1023
1024    i = sprintf(mp_chr(*pool_buf), "%s:%d ", file, line);
1025
1026 again:
1027    maxlen = sizeof_pool_memory(*pool_buf) - i - 1;
1028    va_start(arg_ptr, fmt);
1029    len = bvsnprintf(*pool_buf+i, maxlen, fmt, arg_ptr);
1030    va_end(arg_ptr);
1031    if (len < 0 || len >= maxlen) {
1032       *pool_buf = realloc_pool_memory(*pool_buf, maxlen + i + maxlen/2);
1033       goto again;
1034    }
1035    return len;
1036 }
1037
1038 /*
1039  * Edit a message into a Pool Memory buffer NO file:lineno
1040  *  Returns: string length of what was edited.
1041  */
1042 int Mmsg(POOLMEM **pool_buf, char *fmt, ...)
1043 {
1044    va_list   arg_ptr;
1045    int len, maxlen;
1046
1047 again:
1048    maxlen = sizeof_pool_memory(*pool_buf) - 1;
1049    va_start(arg_ptr, fmt);
1050    len = bvsnprintf(*pool_buf, maxlen, fmt, arg_ptr);
1051    va_end(arg_ptr);
1052    if (len < 0 || len >= maxlen) {
1053       *pool_buf = realloc_pool_memory(*pool_buf, maxlen + maxlen/2);
1054       goto again;
1055    }
1056    return len;
1057 }
1058
1059
1060 /*
1061  * If we come here, prefix the message with the file:line-number,
1062  *  then pass it on to the normal Jmsg routine.
1063  */
1064 void j_msg(char *file, int line, JCR *jcr, int type, int level, char *fmt,...)
1065 {
1066    va_list   arg_ptr;
1067    int i, len, maxlen;
1068    POOLMEM *pool_buf;
1069
1070    pool_buf = get_pool_memory(PM_EMSG);
1071    i = sprintf(pool_buf, "%s:%d ", file, line);
1072
1073 again:
1074    maxlen = sizeof_pool_memory(pool_buf) - i - 1;
1075    va_start(arg_ptr, fmt);
1076    len = bvsnprintf(pool_buf+i, maxlen, fmt, arg_ptr);
1077    va_end(arg_ptr);
1078    if (len < 0 || len >= maxlen) {
1079       pool_buf = realloc_pool_memory(pool_buf, maxlen + i + maxlen/2);
1080       goto again;
1081    }
1082
1083    Jmsg(jcr, type, level, "%s", pool_buf);
1084    free_memory(pool_buf);
1085 }