src/src/log.c

   1 /* $Cambridge: exim/src/src/log.c,v 1.1 2004/10/07 10:39:01 ph10 Exp $ */
   2
   3 /*************************************************
   4 *     Exim - an Internet mail transport agent    *
   5 *************************************************/
   6
   7 /* Copyright (c) University of Cambridge 1995 - 2004 */
   8 /* See the file NOTICE for conditions of use and distribution. */
   9
  10 /* Functions for writing log files. The code for maintaining datestamped
  11 log files was originally contributed by Tony Sheen. */
  12
  13
  14 #include "exim.h"
  15
  16 #define LOG_NAME_SIZE 256
  17 #define MAX_SYSLOG_LEN 870
  18
  19 #define LOG_MODE_FILE   1
  20 #define LOG_MODE_SYSLOG 2
  21
  22 enum { lt_main, lt_reject, lt_panic, lt_process };
  23
  24 static uschar *log_names[] = { US"main", US"reject", US"panic", US"process" };
  25
  26
  27
  28 /*************************************************
  29 *           Local static variables               *
  30 *************************************************/
  31
  32 static uschar mainlog_name[LOG_NAME_SIZE];
  33 static uschar rejectlog_name[LOG_NAME_SIZE];
  34
  35 static uschar *mainlog_datestamp = NULL;
  36 static uschar *rejectlog_datestamp = NULL;
  37
  38 static int    mainlogfd = -1;
  39 static int    rejectlogfd = -1;
  40 static ino_t  mainlog_inode = 0;
  41 static ino_t  rejectlog_inode = 0;
  42
  43 static uschar *panic_save_buffer = NULL;
  44 static BOOL   panic_recurseflag = FALSE;
  45
  46 static BOOL   syslog_open = FALSE;
  47 static BOOL   path_inspected = FALSE;
  48 static int    logging_mode = LOG_MODE_FILE;
  49 static uschar *file_path = US"";
  50
  51
  52
  53
  54 /*************************************************
  55 *              Write to syslog                   *
  56 *************************************************/
  57
  58 /* The given string is split into sections according to length, or at embedded
  59 newlines, and syslogged as a numbered sequence if it is overlong or if there is
  60 more than one line.
  61
  62 Arguments:
  63   priority       syslog priority
  64   s              the string to be written
  65
  66 Returns:         nothing
  67 */
  68
  69 static void
  70 write_syslog(int priority, uschar *s)
  71 {
  72 int len, pass;
  73 int linecount = 0;
  74
  75 if (!syslog_timestamp) s += log_timezone? 26 : 20;
  76
  77 len = Ustrlen(s);
  78
  79 #ifndef NO_OPENLOG
  80 if (!syslog_open)
  81   {
  82   #ifdef SYSLOG_LOG_PID
  83   openlog(CS syslog_processname, LOG_PID|LOG_CONS, syslog_facility);
  84   #else
  85   openlog(CS syslog_processname, LOG_CONS, syslog_facility);
  86   #endif
  87   syslog_open = TRUE;
  88   }
  89 #endif
  90
  91 /* First do a scan through the message in order to determine how many lines
  92 it is going to end up as. Then rescan to output it. */
  93
  94 for (pass = 0; pass < 2; pass++)
  95   {
  96   int i;
  97   int tlen;
  98   uschar *ss = s;
  99   for (i = 1, tlen = len; tlen > 0; i++)
 100     {
 101     int plen = tlen;
 102     uschar *nlptr = Ustrchr(ss, '\n');
 103     if (nlptr != NULL) plen = nlptr - ss;
 104     #ifndef SYSLOG_LONG_LINES
 105     if (plen > MAX_SYSLOG_LEN) plen = MAX_SYSLOG_LEN;
 106     #endif
 107     tlen -= plen;
 108     if (ss[plen] == '\n') tlen--;    /* chars left */
 109
 110     if (pass == 0) linecount++; else
 111       {
 112       if (linecount == 1)
 113         syslog(priority, "%.*s", plen, ss);
 114       else
 115         syslog(priority, "[%d%c%d] %.*s", i,
 116           (ss[plen] == '\n' && tlen != 0)? '\\' : '/',
 117           linecount, plen, ss);
 118       }
 119     ss += plen;
 120     if (*ss == '\n') ss++;
 121     }
 122   }
 123 }
 124
 125
 126
 127 /*************************************************
 128 *             Die tidily                         *
 129 *************************************************/
 130
 131 /* This is called when Exim is dying as a result of something going wrong in
 132 the logging, or after a log call with LOG_PANIC_DIE set. Optionally write a
 133 message to debug_file or a stderr file, if they exist. Then, if in the middle
 134 of accepting a message, throw it away tidily; this will attempt to send an SMTP
 135 response if appropriate. Otherwise, try to close down an outstanding SMTP call
 136 tidily.
 137
 138 Arguments:
 139   s1         Error message to write to debug_file and/or stderr and syslog
 140   s2         Error message for any SMTP call that is in progress
 141 Returns:     The function does not return
 142 */
 143
 144 static void
 145 die(uschar *s1, uschar *s2)
 146 {
 147 if (s1 != NULL)
 148   {
 149   write_syslog(LOG_CRIT, s1);
 150   if (debug_file != NULL) debug_printf("%s\n", s1);
 151   if (log_stderr != NULL && log_stderr != debug_file)
 152     fprintf(log_stderr, "%s\n", s1);
 153   }
 154 if (receive_call_bombout) receive_bomb_out(s2);  /* does not return */
 155 if (smtp_input) smtp_closedown(s2);
 156 exim_exit(EXIT_FAILURE);
 157 }
 158
 159
 160
 161 /*************************************************
 162 *             Create a log file                  *
 163 *************************************************/
 164
 165 /* This function is called to create and open a log file. It may be called in a
 166 subprocess when the original process is root.
 167
 168 Arguments:
 169   name         the file name
 170
 171 The file name has been build in a working buffer, so it is permissible to
 172 overwrite it temporarily if it is necessary to create the directory.
 173
 174 Returns:       a file descriptor, or < 0 on failure (errno set)
 175 */
 176
 177 static int
 178 create_log(uschar *name)
 179 {
 180 int fd = Uopen(name, O_CREAT|O_APPEND|O_WRONLY, LOG_MODE);
 181
 182 /* If creation failed, attempt to build a log directory in case that is the
 183 problem. */
 184
 185 if (fd < 0 && errno == ENOENT)
 186   {
 187   BOOL created;
 188   uschar *lastslash = Ustrrchr(name, '/');
 189   *lastslash = 0;
 190   created = directory_make(NULL, name, LOG_DIRECTORY_MODE, FALSE);
 191   DEBUG(D_any) debug_printf("%s log directory %s\n",
 192     created? "created" : "failed to create", name);
 193   *lastslash = '/';
 194   if (created) fd = Uopen(name, O_CREAT|O_APPEND|O_WRONLY, LOG_MODE);
 195   }
 196
 197 return fd;
 198 }
 199
 200
 201
 202
 203 /*************************************************
 204 *                Open a log file                 *
 205 *************************************************/
 206
 207 /* This function opens one of a number of logs, which all (except for the
 208 "process log") reside in the same directory, creating the directory if it does
 209 not exist. This may be called recursively on failure, in order to open the
 210 panic log.
 211
 212 The directory is in the static variable file_path. This is static so that it
 213 the work of sorting out the path is done just once per Exim process.
 214
 215 Exim is normally configured to avoid running as root wherever possible, the log
 216 files must be owned by the non-privileged exim user. To ensure this, first try
 217 an open without O_CREAT - most of the time this will succeed. If it fails, try
 218 to create the file; if running as root, this must be done in a subprocess to
 219 avoid races.
 220
 221 Arguments:
 222   fd         where to return the resulting file descriptor
 223   type       lt_main, lt_reject, lt_panic, or lt_process
 224
 225 Returns:   nothing
 226 */
 227
 228 static void
 229 open_log(int *fd, int type)
 230 {
 231 uid_t euid;
 232 BOOL ok;
 233 uschar buffer[LOG_NAME_SIZE];
 234
 235 /* Sort out the file name. This depends on the type of log we are opening. The
 236 process "log" is written in the spool directory by default, but a path name can
 237 be specified in the configuration. */
 238
 239 if (type == lt_process)
 240   {
 241   if (process_log_path == NULL)
 242     ok = string_format(buffer, sizeof(buffer), "%s/exim-process.info",
 243       spool_directory);
 244   else
 245     ok = string_format(buffer, sizeof(buffer), "%s", process_log_path);
 246   }
 247
 248 /* The names of the other three logs are controlled by file_path. The panic log
 249 is written to the same directory as the main and reject logs, but its name does
 250 not have a datestamp. The use of datestamps is indicated by %D in file_path.
 251 When opening the panic log, if %D is present, we remove the datestamp from the
 252 generated name; if it is at the start, remove a following non-alphameric
 253 character as well; otherwise, remove a preceding non-alphameric character. This
 254 is definitely kludgy, but it sort of does what people want, I hope. */
 255
 256 else
 257   {
 258   ok = string_format(buffer, sizeof(buffer), CS file_path, log_names[type]);
 259
 260   /* Save the name of the mainlog for rollover processing. Without a datestamp,
 261   it gets statted to see if it has been cycled. With a datestamp, the datestamp
 262   will be compared. The static slot for saving it is the same size as buffer,
 263   and the text has been checked above to fit, so this use of strcpy() is OK. */
 264
 265   if (type == lt_main)
 266     {
 267     Ustrcpy(mainlog_name, buffer);
 268     mainlog_datestamp = mainlog_name + string_datestamp_offset;
 269     }
 270
 271   /* Ditto for the reject log */
 272
 273   else if (type == lt_reject)
 274     {
 275     Ustrcpy(rejectlog_name, buffer);
 276     rejectlog_datestamp = rejectlog_name + string_datestamp_offset;
 277     }
 278
 279   /* Remove any datestamp if this is the panic log. This is rare, so there's no
 280   need to optimize getting the datestamp length. We remove one non-alphanumeric
 281   char afterwards if at the start, otherwise one before. */
 282
 283   else if (string_datestamp_offset >= 0)
 284     {
 285     uschar *from = buffer + string_datestamp_offset;
 286     uschar *to = from + Ustrlen(tod_stamp(tod_log_datestamp));
 287     if (from == buffer || from[-1] == '/')
 288       {
 289       if (!isalnum(*to)) to++;
 290       }
 291     else
 292       {
 293       if (!isalnum(from[-1])) from--;
 294       }
 295
 296     /* This strcpy is ok, because we know that to is a substring of from. */
 297
 298     Ustrcpy(from, to);
 299     }
 300   }
 301
 302 /* If the file name is too long, it is an unrecoverable disaster */
 303
 304 if (!ok)
 305   {
 306   die(US"exim: log file path too long: aborting",
 307       US"Logging failure; please try later");
 308   }
 309
 310 /* We now have the file name. Try to open an existing file. After a successful
 311 open, arrange for automatic closure on exec(), and then return. */
 312
 313 *fd = Uopen(buffer, O_APPEND|O_WRONLY, LOG_MODE);
 314
 315 if (*fd >= 0)
 316   {
 317   fcntl(*fd, F_SETFD, fcntl(*fd, F_GETFD) | FD_CLOEXEC);
 318   return;
 319   }
 320
 321 /* Open was not successful: try creating the file. If this is a root process,
 322 we must do the creating in a subprocess set to exim:exim in order to ensure
 323 that the file is created with the right ownership. Otherwise, there can be a
 324 race if an exim process is trying to write to the log at the same time. The use
 325 of SIGUSR1 by the exiwhat utility can provoke a lot of simultaneous writing. */
 326
 327 euid = geteuid();
 328
 329 /* If we are already running as the Exim user (even if that user is root),
 330 we can go ahead and create in the current process. */
 331
 332 if (euid == exim_uid) *fd = create_log(buffer);
 333
 334 /* Otherwise, if we are root, do the creation in an exim:exim subprocess. If we
 335 are neither exim nor root, creation is not attempted. */
 336
 337 else if (euid == root_uid)
 338   {
 339   int status;
 340   pid_t pid = fork();
 341
 342   /* In the subprocess, change uid/gid and do the creation. Return 0 from the
 343   subprocess on success. There doesn't seem much point in testing for setgid
 344   and setuid errors. */
 345
 346   if (pid == 0)
 347     {
 348     (void)setgid(exim_gid);
 349     (void)setuid(exim_uid);
 350     _exit((create_log(buffer) < 0)? 1 : 0);
 351     }
 352
 353   /* Wait for the subprocess. If it succeeded retry the open. */
 354
 355   while (waitpid(pid, &status, 0) != pid);
 356   if (status == 0) *fd = Uopen(buffer, O_APPEND|O_WRONLY, LOG_MODE);
 357   }
 358
 359 /* If we now have an open file, set the close-on-exec flag and return. */
 360
 361 if (*fd >= 0)
 362   {
 363   fcntl(*fd, F_SETFD, fcntl(*fd, F_GETFD) | FD_CLOEXEC);
 364   return;
 365   }
 366
 367 /* Creation failed. There are some circumstances in which we get here when
 368 the effective uid is not root or exim, which is the problem. (For example, a
 369 non-setuid binary with log_arguments set, called in certain ways.) Rather than
 370 just bombing out, force the log to stderr and carry on if stderr is available.
 371 */
 372
 373 if (euid != root_uid && euid != exim_uid && log_stderr != NULL)
 374   {
 375   *fd = fileno(log_stderr);
 376   return;
 377   }
 378
 379 /* Otherwise this is a disaster. This call is deliberately ONLY to the panic
 380 log. If possible, save a copy of the original line that was being logged. If we
 381 are recursing (can't open the panic log either), the pointer will already be
 382 set. */
 383
 384 if (panic_save_buffer == NULL)
 385   {
 386   panic_save_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
 387   if (panic_save_buffer != NULL)
 388     memcpy(panic_save_buffer, log_buffer, LOG_BUFFER_SIZE);
 389   }
 390
 391 log_write(0, LOG_PANIC_DIE, "Cannot open %s log file \"%s\": %s: "
 392   "euid=%d egid=%d", log_names[type], buffer, strerror(errno), euid, getegid());
 393 /* Never returns */
 394 }
 395
 396
 397
 398 /*************************************************
 399 *     Add configuration file info to log line    *
 400 *************************************************/
 401
 402 /* This is put in a function because it's needed twice (once for debugging,
 403 once for real).
 404
 405 Arguments:
 406   ptr         pointer to the end of the line we are building
 407   flags       log flags
 408
 409 Returns:      updated pointer
 410 */
 411
 412 static uschar *
 413 log_config_info(uschar *ptr, int flags)
 414 {
 415 Ustrcpy(ptr, "Exim configuration error");
 416 ptr += 24;
 417
 418 if ((flags & (LOG_CONFIG_FOR & ~LOG_CONFIG)) != 0)
 419   {
 420   Ustrcpy(ptr, " for ");
 421   return ptr + 5;
 422   }
 423
 424 if ((flags & (LOG_CONFIG_IN & ~LOG_CONFIG)) != 0)
 425   {
 426   sprintf(CS ptr, " in line %d of %s", config_lineno, config_filename);
 427   while (*ptr) ptr++;
 428   }
 429
 430 Ustrcpy(ptr, ":\n  ");
 431 return ptr + 4;
 432 }
 433
 434
 435 /*************************************************
 436 *           A write() operation failed           *
 437 *************************************************/
 438
 439 /* This function is called when write() fails on anything other than the panic
 440 log, which can happen if a disk gets full or a file gets too large or whatever.
 441 We try to save the relevant message in the panic_save buffer before crashing
 442 out.
 443
 444 Arguments:
 445   name      the name of the log being written
 446   length    the string length being written
 447   rc        the return value from write()
 448
 449 Returns:    does not return
 450 */
 451
 452 static void
 453 log_write_failed(uschar *name, int length, int rc)
 454 {
 455 int save_errno = errno;
 456
 457 if (panic_save_buffer == NULL)
 458   {
 459   panic_save_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
 460   if (panic_save_buffer != NULL)
 461     memcpy(panic_save_buffer, log_buffer, LOG_BUFFER_SIZE);
 462   }
 463
 464 log_write(0, LOG_PANIC_DIE, "failed to write to %s: length=%d result=%d "
 465   "errno=%d (%s)", name, length, rc, save_errno,
 466   (save_errno == 0)? "write incomplete" : strerror(save_errno));
 467 /* Never returns */
 468 }
 469
 470
 471
 472 /*************************************************
 473 *            Write message to log file           *
 474 *************************************************/
 475
 476 /* Exim can be configured to log to local files, or use syslog, or both. This
 477 is controlled by the setting of log_file_path. The following cases are
 478 recognized:
 479
 480   log_file_path = ""               write files in the spool/log directory
 481   log_file_path = "xxx"            write files in the xxx directory
 482   log_file_path = "syslog"         write to syslog
 483   log_file_path = "syslog : xxx"   write to syslog and to files (any order)
 484
 485 The one exception to this is messages containing LOG_PROCESS. These are always
 486 written to exim-process.info in the spool directory. They aren't really log
 487 messages in the same sense as the others.
 488
 489 The message always gets '\n' added on the end of it, since more than one
 490 process may be writing to the log at once and we don't want intermingling to
 491 happen in the middle of lines. To be absolutely sure of this we write the data
 492 into a private buffer and then put it out in a single write() call.
 493
 494 The flags determine which log(s) the message is written to, or for syslogging,
 495 which priority to use, and in the case of the panic log, whether the process
 496 should die afterwards.
 497
 498 The variable really_exim is TRUE only when exim is running in privileged state
 499 (i.e. not with a changed configuration or with testing options such as -brw).
 500 If it is not, don't try to write to the log because permission will probably be
 501 denied.
 502
 503 Avoid actually writing to the logs when exim is called with -bv or -bt to
 504 test an address, but take other actions, such as panicing.
 505
 506 In Exim proper, the buffer for building the message is got at start-up, so that
 507 nothing gets done if it can't be got. However, some functions that are also
 508 used in utilities occasionally obey log_write calls in error situations, and it
 509 is simplest to put a single malloc() here rather than put one in each utility.
 510 Malloc is used directly because the store functions may call log_write().
 511
 512 If a message_id exists, we include it after the timestamp.
 513
 514 Arguments:
 515   selector  write to main log or LOG_INFO only if this value is zero, or if
 516               its bit is set in log_write_selector
 517   flags     each bit indicates some independent action:
 518               LOG_SENDER      add raw sender to the message
 519               LOG_RECIPIENTS  add raw recipients list to message
 520               LOG_CONFIG      add "Exim configuration error"
 521               LOG_CONFIG_FOR  add " for " instead of ":\n  "
 522               LOG_CONFIG_IN   add " in line x[ of file y]"
 523               LOG_MAIN        write to main log or syslog LOG_INFO
 524               LOG_REJECT      write to reject log or syslog LOG_NOTICE
 525               LOG_PANIC       write to panic log or syslog LOG_ALERT
 526               LOG_PANIC_DIE   write to panic log or LOG_ALERT and then crash
 527               LOG_PROCESS     write to process log (always a file)
 528   format    a printf() format
 529   ...       arguments for format
 530
 531 Returns:    nothing
 532 */
 533
 534 void
 535 log_write(unsigned int selector, int flags, char *format, ...)
 536 {
 537 uschar *ptr;
 538 int length, rc;
 539 int paniclogfd;
 540 va_list ap;
 541
 542 /* If panic_recurseflag is set, we have failed to open the panic log. This is
 543 the ultimate disaster. First try to write the message to a debug file and/or
 544 stderr and also to syslog. If panic_save_buffer is not NULL, it contains the
 545 original log line that caused the problem. Afterwards, expire. */
 546
 547 if (panic_recurseflag)
 548   {
 549   uschar *extra = (panic_save_buffer == NULL)? US"" : panic_save_buffer;
 550   if (debug_file != NULL) debug_printf("%s%s", extra, log_buffer);
 551   if (log_stderr != NULL && log_stderr != debug_file)
 552     fprintf(log_stderr, "%s%s", extra, log_buffer);
 553   if (*extra != 0) write_syslog(LOG_CRIT, extra);
 554   write_syslog(LOG_CRIT, log_buffer);
 555   die(US"exim: could not open panic log - aborting: see message(s) above",
 556     US"Unexpected log failure, please try later");
 557   }
 558
 559 /* Ensure we have a buffer (see comment above); this should never be obeyed
 560 when running Exim proper, only when running utilities. */
 561
 562 if (log_buffer == NULL)
 563   {
 564   log_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
 565   if (log_buffer == NULL)
 566     {
 567     fprintf(stderr, "exim: failed to get store for log buffer\n");
 568     exim_exit(EXIT_FAILURE);
 569     }
 570   }
 571
 572 /* If we haven't already done so, inspect the setting of log_file_path to
 573 determine whether to log to files and/or to syslog. Bits in logging_mode
 574 control this, and for file logging, the path must end up in file_path. This
 575 variable must be in permanent store because it may be required again later in
 576 the process. */
 577
 578 if (!path_inspected)
 579   {
 580   BOOL multiple = FALSE;
 581   int old_pool = store_pool;
 582
 583   store_pool = POOL_PERM;
 584
 585   /* If nothing has been set, don't waste effort... the default values for the
 586   statics are file_path="" and logging_mode = LOG_MODE_FILE. */
 587
 588   if (log_file_path[0] != 0)
 589     {
 590     int sep = ':';              /* Fixed separator - outside use */
 591     uschar *s;
 592     uschar *ss = log_file_path;
 593     logging_mode = 0;
 594     while ((s = string_nextinlist(&ss,&sep,log_buffer,LOG_BUFFER_SIZE)) != NULL)
 595       {
 596       if (Ustrcmp(s, "syslog") == 0)
 597         logging_mode |= LOG_MODE_SYSLOG;
 598       else if ((logging_mode & LOG_MODE_FILE) != 0) multiple = TRUE;
 599       else
 600         {
 601         logging_mode |= LOG_MODE_FILE;
 602
 603         /* If a non-empty path is given, use it */
 604
 605         if (s[0] != 0)
 606           {
 607           file_path = string_copy(s);
 608           }
 609
 610         /* If the path is empty, we want to use the first non-empty, non-
 611         syslog item in LOG_FILE_PATH, if there is one, since the value of
 612         log_file_path may have been set at runtime. If there is no such item,
 613         use the ultimate default in the spool directory. */
 614
 615         else
 616           {
 617           uschar *t;
 618           uschar *tt = US LOG_FILE_PATH;
 619           while ((t = string_nextinlist(&tt,&sep,log_buffer,LOG_BUFFER_SIZE))
 620                 != NULL)
 621             {
 622             if (Ustrcmp(t, "syslog") == 0 || t[0] == 0) continue;
 623             file_path = string_copy(t);
 624             break;
 625             }
 626           }  /* Empty item in log_file_path */
 627         }    /* First non-syslog item in log_file_path */
 628       }      /* Scan of log_file_path */
 629     }
 630
 631   /* If no modes have been selected, it is a major disaster */
 632
 633   if (logging_mode == 0)
 634     die(US"Neither syslog nor file logging set in log_file_path",
 635         US"Unexpected logging failure");
 636
 637   /* Set up the ultimate default if necessary. Then revert to the old store
 638   pool, and record that we've sorted out the path. */
 639
 640   if ((logging_mode & LOG_MODE_FILE) != 0 && file_path[0] == 0)
 641     file_path = string_sprintf("%s/log/%%slog", spool_directory);
 642   store_pool = old_pool;
 643   path_inspected = TRUE;
 644
 645   /* If more than one file path was given, log a complaint. This recursive call
 646   should work since we have now set up the routing. */
 647
 648   if (multiple)
 649     {
 650     log_write(0, LOG_MAIN|LOG_PANIC,
 651       "More than one path given in log_file_path: using %s", file_path);
 652     }
 653   }
 654
 655 /* If debugging, show all log entries, but don't show headers. Do it all
 656 in one go so that it doesn't get split when multi-processing. */
 657
 658 DEBUG(D_any|D_v)
 659   {
 660   int i;
 661   ptr = log_buffer;
 662
 663   Ustrcpy(ptr, "LOG:");
 664   ptr += 4;
 665
 666   /* Show the options that were passed into the call. These are those whose
 667   flag values do not have the 0x80000000 bit in them. Note that this
 668   automatically exclude the "all" setting. */
 669
 670   for (i = 0; i < log_options_count; i++)
 671     {
 672     unsigned int bit = log_options[i].bit;
 673     if ((bit & 0x80000000) != 0) continue;
 674     if ((selector & bit) != 0)
 675       {
 676       *ptr++ = ' ';
 677       Ustrcpy(ptr, log_options[i].name);
 678       while (*ptr) ptr++;
 679       }
 680     }
 681
 682   sprintf(CS ptr, "%s%s%s%s%s\n  ",
 683     ((flags & LOG_MAIN) != 0)?    " MAIN"   : "",
 684     ((flags & LOG_PANIC) != 0)?   " PANIC"  : "",
 685     ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE)? " DIE" : "",
 686     ((flags & LOG_PROCESS) != 0)? " PROCESS": "",
 687     ((flags & LOG_REJECT) != 0)?  " REJECT" : "");
 688
 689   while(*ptr) ptr++;
 690   if ((flags & LOG_CONFIG) != 0) ptr = log_config_info(ptr, flags);
 691
 692   va_start(ap, format);
 693   if (!string_vformat(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer)-1, format, ap))
 694     Ustrcpy(ptr, "**** log string overflowed log buffer ****");
 695   va_end(ap);
 696
 697   while(*ptr) ptr++;
 698   Ustrcat(ptr, "\n");
 699   debug_printf("%s", log_buffer);
 700   }
 701
 702 /* If no log file is specified, we are in a mess. */
 703
 704 if ((flags & (LOG_MAIN|LOG_PANIC|LOG_REJECT|LOG_PROCESS)) == 0)
 705   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_write called with no log "
 706     "flags set");
 707
 708 /* There are some weird circumstances in which logging is disabled. */
 709
 710 if (disable_logging)
 711   {
 712   DEBUG(D_any) debug_printf("log writing disabled\n");
 713   return;
 714   }
 715
 716 /* Create the main message in the log buffer, including the message
 717 id except for the process log and when called by a utility. */
 718
 719 ptr = log_buffer;
 720 if (really_exim && (flags & LOG_PROCESS) == 0 && message_id[0] != 0)
 721   sprintf(CS ptr, "%s %s ", tod_stamp(tod_log), message_id);
 722 else sprintf(CS ptr, "%s ", tod_stamp(tod_log));
 723
 724 while(*ptr) ptr++;
 725 if ((flags & LOG_CONFIG) != 0) ptr = log_config_info(ptr, flags);
 726
 727 va_start(ap, format);
 728 if (!string_vformat(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer)-1, format, ap))
 729   Ustrcpy(ptr, "**** log string overflowed log buffer ****\n");
 730 while(*ptr) ptr++;
 731 va_end(ap);
 732
 733 /* Add the raw, unrewritten, sender to the message if required. This is done
 734 this way because it kind of fits with LOG_RECIPIENTS. */
 735
 736 if ((flags & LOG_SENDER) != 0 &&
 737     ptr < log_buffer + LOG_BUFFER_SIZE - 8 - Ustrlen(raw_sender))
 738   {
 739   sprintf(CS ptr, " from <%s>", raw_sender);
 740   while (*ptr) ptr++;
 741   }
 742
 743 /* Add list of recipients to the message if required; the raw list,
 744 before rewriting, was saved in raw_recipients. There may be none, if an ACL
 745 discarded them all. */
 746
 747 if ((flags & LOG_RECIPIENTS) != 0 && ptr < log_buffer + LOG_BUFFER_SIZE - 6 &&
 748      raw_recipients_count > 0)
 749   {
 750   int i;
 751   sprintf(CS ptr, " for");
 752   while (*ptr) ptr++;
 753   for (i = 0; i < raw_recipients_count; i++)
 754     {
 755     uschar *s = raw_recipients[i];
 756     if (log_buffer + LOG_BUFFER_SIZE - ptr < Ustrlen(s) + 3) break;
 757     sprintf(CS ptr, " %s", s);
 758     while (*ptr) ptr++;
 759     }
 760   }
 761
 762 sprintf(CS  ptr, "\n");
 763 while(*ptr) ptr++;
 764 length = ptr - log_buffer;
 765
 766 /* Handle loggable errors when running a utility, or when address testing.
 767 Write to log_stderr unless debugging (when it will already have been written),
 768 or unless there is no log_stderr (expn called from daemon, for example). */
 769
 770 if (!really_exim || log_testing_mode)
 771   {
 772   if (debug_selector == 0 && log_stderr != NULL &&
 773       (selector == 0 || (selector & log_write_selector) != 0))
 774     {
 775     if (host_checking)
 776       fprintf(log_stderr, "LOG: %s", CS(log_buffer + 20));  /* no timestamp */
 777     else
 778       fprintf(log_stderr, "%s", CS log_buffer);
 779     }
 780   if ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE) exim_exit(EXIT_FAILURE);
 781   return;
 782   }
 783
 784 /* Handle the main log. We know that either syslog or file logging (or both) is
 785 set up. A real file gets left open during reception or delivery once it has
 786 been opened, but we don't want to keep on writing to it for too long after it
 787 has been renamed. Therefore, do a stat() and see if the inode has changed, and
 788 if so, re-open. */
 789
 790 if ((flags & LOG_MAIN) != 0 &&
 791     (selector == 0 || (selector & log_write_selector) != 0))
 792   {
 793   if ((logging_mode & LOG_MODE_SYSLOG) != 0 &&
 794       (syslog_duplication || (flags & (LOG_REJECT|LOG_PANIC)) == 0))
 795     write_syslog(LOG_INFO, log_buffer);
 796
 797   if ((logging_mode & LOG_MODE_FILE) != 0)
 798     {
 799     struct stat statbuf;
 800
 801     /* Check for a change to the mainlog file name when datestamping is in
 802     operation. This happens at midnight, at which point we want to roll over
 803     the file. Closing it has the desired effect. */
 804
 805     if (mainlog_datestamp != NULL)
 806       {
 807       uschar *nowstamp = tod_stamp(tod_log_datestamp);
 808       if (Ustrncmp (mainlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
 809         {
 810         close(mainlogfd);             /* Close the file */
 811         mainlogfd = -1;               /* Clear the file descriptor */
 812         mainlog_inode = 0;            /* Unset the inode */
 813         mainlog_datestamp = NULL;     /* Clear the datestamp */
 814         }
 815       }
 816
 817     /* Otherwise, we want to check whether the file has been renamed by a
 818     cycling script. This could be "if else", but for safety's sake, leave it as
 819     "if" so that renaming the log starts a new file even when datestamping is
 820     happening. */
 821
 822     if (mainlogfd >= 0)
 823       {
 824       if (Ustat(mainlog_name, &statbuf) < 0 || statbuf.st_ino != mainlog_inode)
 825         {
 826         close(mainlogfd);
 827         mainlogfd = -1;
 828         mainlog_inode = 0;
 829         }
 830       }
 831
 832     /* If the log is closed, open it. Then write the line. */
 833
 834     if (mainlogfd < 0)
 835       {
 836       open_log(&mainlogfd, lt_main);     /* No return on error */
 837       if (fstat(mainlogfd, &statbuf) >= 0) mainlog_inode = statbuf.st_ino;
 838       }
 839
 840     /* Failing to write to the log is disastrous */
 841
 842     if ((rc = write(mainlogfd, log_buffer, length)) != length)
 843       {
 844       log_write_failed(US"main log", length, rc);
 845       /* That function does not return */
 846       }
 847     }
 848   }
 849
 850 /* Handle the log for rejected messages. This can be globally disabled. If
 851 there are any header lines (i.e. if the rejection is happening after the DATA
 852 phase), log the recipients and the headers. */
 853
 854 if (write_rejectlog && (flags & LOG_REJECT) != 0)
 855   {
 856   header_line *h;
 857
 858   if (header_list != NULL && (log_extra_selector & LX_rejected_header) != 0)
 859     {
 860     if (recipients_count > 0)
 861       {
 862       int i;
 863
 864       /* List the sender */
 865
 866       string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 867         "Envelope-from: <%s>\n", sender_address);
 868       while (*ptr) ptr++;
 869
 870       /* List up to 5 recipients */
 871
 872       string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 873         "Envelope-to: <%s>\n", recipients_list[0].address);
 874       while (*ptr) ptr++;
 875
 876       for (i = 1; i < recipients_count && i < 5; i++)
 877         {
 878         string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer), "    <%s>\n",
 879           recipients_list[i].address);
 880         while (*ptr) ptr++;
 881         }
 882
 883       if (i < recipients_count)
 884         {
 885         (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 886           "    ...\n");
 887         while (*ptr) ptr++;
 888         }
 889       }
 890
 891     /* A header with a NULL text is an unfilled in Received: header */
 892
 893     for (h = header_list; h != NULL; h = h->next)
 894       {
 895       BOOL fitted;
 896       if (h->text == NULL) continue;
 897       fitted = string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 898         "%c %s", h->type, h->text);
 899       while(*ptr) ptr++;
 900       if (!fitted)         /* Buffer is full; truncate */
 901         {
 902         ptr -= 100;        /* For message and separator */
 903         if (ptr[-1] == '\n') ptr--;
 904         Ustrcpy(ptr, "\n*** truncated ***\n");
 905         while (*ptr) ptr++;
 906         break;
 907         }
 908       }
 909
 910     length = ptr - log_buffer;
 911     }
 912
 913   /* Write to syslog or to a log file */
 914
 915   if ((logging_mode & LOG_MODE_SYSLOG) != 0 &&
 916       (syslog_duplication || (flags & LOG_PANIC) == 0))
 917     write_syslog(LOG_NOTICE, log_buffer);
 918
 919   /* Check for a change to the rejectlog file name when datestamping is in
 920   operation. This happens at midnight, at which point we want to roll over
 921   the file. Closing it has the desired effect. */
 922
 923   if ((logging_mode & LOG_MODE_FILE) != 0)
 924     {
 925     struct stat statbuf;
 926
 927     if (rejectlog_datestamp != NULL)
 928       {
 929       uschar *nowstamp = tod_stamp(tod_log_datestamp);
 930       if (Ustrncmp (rejectlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
 931         {
 932         close(rejectlogfd);             /* Close the file */
 933         rejectlogfd = -1;               /* Clear the file descriptor */
 934         rejectlog_inode = 0;            /* Unset the inode */
 935         rejectlog_datestamp = NULL;     /* Clear the datestamp */
 936         }
 937       }
 938
 939     /* Otherwise, we want to check whether the file has been renamed by a
 940     cycling script. This could be "if else", but for safety's sake, leave it as
 941     "if" so that renaming the log starts a new file even when datestamping is
 942     happening. */
 943
 944     if (rejectlogfd >= 0)
 945       {
 946       if (Ustat(rejectlog_name, &statbuf) < 0 ||
 947            statbuf.st_ino != rejectlog_inode)
 948         {
 949         close(rejectlogfd);
 950         rejectlogfd = -1;
 951         rejectlog_inode = 0;
 952         }
 953       }
 954
 955     /* Open the file if necessary, and write the data */
 956
 957     if (rejectlogfd < 0)
 958       {
 959       open_log(&rejectlogfd, lt_reject); /* No return on error */
 960       if (fstat(rejectlogfd, &statbuf) >= 0) rejectlog_inode = statbuf.st_ino;
 961       }
 962
 963     if ((rc = write(rejectlogfd, log_buffer, length)) != length)
 964       {
 965       log_write_failed(US"reject log", length, rc);
 966       /* That function does not return */
 967       }
 968     }
 969   }
 970
 971
 972 /* Handle the process log file, where exim processes can be made to dump
 973 details of what they are doing by sending them a USR1 signal. Note that
 974 a message id is not automatically added above. This information is always
 975 written to a file - never to syslog. */
 976
 977 if ((flags & LOG_PROCESS) != 0)
 978   {
 979   int processlogfd;
 980   open_log(&processlogfd, lt_process);  /* No return on error */
 981   if ((rc = write(processlogfd, log_buffer, length)) != length)
 982     {
 983     log_write_failed(US"process log", length, rc);
 984     /* That function does not return */
 985     }
 986   (void)close(processlogfd);
 987   }
 988
 989
 990 /* Handle the panic log, which is not kept open like the others. If it fails to
 991 open, there will be a recursive call to log_write(). We detect this above and
 992 attempt to write to the system log as a last-ditch try at telling somebody. In
 993 all cases, try to write to log_stderr. */
 994
 995 if ((flags & LOG_PANIC) != 0)
 996   {
 997   if (log_stderr != NULL && log_stderr != debug_file)
 998     fprintf(log_stderr, "%s", CS log_buffer);
 999
1000   if ((logging_mode & LOG_MODE_SYSLOG) != 0)
1001     {
1002     write_syslog(LOG_ALERT, log_buffer);
1003     }
1004
1005   /* If this panic logging was caused by a failure to open the main log,
1006   the original log line is in panic_save_buffer. Make an attempt to write it. */
1007
1008   if ((logging_mode & LOG_MODE_FILE) != 0)
1009     {
1010     panic_recurseflag = TRUE;
1011     open_log(&paniclogfd, lt_panic);  /* Won't return on failure */
1012     panic_recurseflag = FALSE;
1013
1014     if (panic_save_buffer != NULL)
1015       (void) write(paniclogfd, panic_save_buffer, Ustrlen(panic_save_buffer));
1016
1017     if ((rc = write(paniclogfd, log_buffer, length)) != length)
1018       {
1019       int save_errno = errno;
1020       write_syslog(LOG_CRIT, log_buffer);
1021       sprintf(CS log_buffer, "write failed on panic log: length=%d result=%d "
1022         "errno=%d (%s)", length, rc, save_errno, strerror(save_errno));
1023       write_syslog(LOG_CRIT, log_buffer);
1024       flags |= LOG_PANIC_DIE;
1025       }
1026
1027     close(paniclogfd);
1028     }
1029
1030   /* Give up if the DIE flag is set */
1031
1032   if ((flags & LOG_PANIC_DIE) != LOG_PANIC)
1033     die(NULL, US"Unexpected failure, please try later");
1034   }
1035 }
1036
1037
1038
1039 /*************************************************
1040 *            Close any open log files            *
1041 *************************************************/
1042
1043 void
1044 log_close_all(void)
1045 {
1046 if (mainlogfd >= 0)
1047   { close(mainlogfd); mainlogfd = -1; }
1048 if (rejectlogfd >= 0)
1049   { close(rejectlogfd); rejectlogfd = -1; }
1050 closelog();
1051 syslog_open = FALSE;
1052 }
1053
1054 /* End of log.c */