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