src/src/log.c

   1 /* $Cambridge: exim/src/src/log.c,v 1.6 2005/06/28 10:23:35 ph10 Exp $ */
   2
   3 /*************************************************
   4 *     Exim - an Internet mail transport agent    *
   5 *************************************************/
   6
   7 /* Copyright (c) University of Cambridge 1995 - 2005 */
   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   (void)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 another Exim process is trying to write to the log at the same time.
 325 The use of SIGUSR1 by the exiwhat utility can provoke a lot of simultaneous
 326 writing. */
 327
 328 euid = geteuid();
 329
 330 /* If we are already running as the Exim user (even if that user is root),
 331 we can go ahead and create in the current process. */
 332
 333 if (euid == exim_uid) *fd = create_log(buffer);
 334
 335 /* Otherwise, if we are root, do the creation in an exim:exim subprocess. If we
 336 are neither exim nor root, creation is not attempted. */
 337
 338 else if (euid == root_uid)
 339   {
 340   int status;
 341   pid_t pid = fork();
 342
 343   /* In the subprocess, change uid/gid and do the creation. Return 0 from the
 344   subprocess on success. There doesn't seem much point in testing for setgid
 345   and setuid errors. */
 346
 347   if (pid == 0)
 348     {
 349     (void)setgid(exim_gid);
 350     (void)setuid(exim_uid);
 351     _exit((create_log(buffer) < 0)? 1 : 0);
 352     }
 353
 354   /* If we created a subprocess, wait for it. If it succeeded retry the open. */
 355
 356   if (pid > 0)
 357     {
 358     while (waitpid(pid, &status, 0) != pid);
 359     if (status == 0) *fd = Uopen(buffer, O_APPEND|O_WRONLY, LOG_MODE);
 360     }
 361
 362   /* If we failed to create a subprocess, we are in a bad way. We fall through
 363   with *fd still < 0, and errno set, letting the code below handle the error. */
 364   }
 365
 366 /* If we now have an open file, set the close-on-exec flag and return. */
 367
 368 if (*fd >= 0)
 369   {
 370   (void)fcntl(*fd, F_SETFD, fcntl(*fd, F_GETFD) | FD_CLOEXEC);
 371   return;
 372   }
 373
 374 /* Creation failed. There are some circumstances in which we get here when
 375 the effective uid is not root or exim, which is the problem. (For example, a
 376 non-setuid binary with log_arguments set, called in certain ways.) Rather than
 377 just bombing out, force the log to stderr and carry on if stderr is available.
 378 */
 379
 380 if (euid != root_uid && euid != exim_uid && log_stderr != NULL)
 381   {
 382   *fd = fileno(log_stderr);
 383   return;
 384   }
 385
 386 /* Otherwise this is a disaster. This call is deliberately ONLY to the panic
 387 log. If possible, save a copy of the original line that was being logged. If we
 388 are recursing (can't open the panic log either), the pointer will already be
 389 set. */
 390
 391 if (panic_save_buffer == NULL)
 392   {
 393   panic_save_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
 394   if (panic_save_buffer != NULL)
 395     memcpy(panic_save_buffer, log_buffer, LOG_BUFFER_SIZE);
 396   }
 397
 398 log_write(0, LOG_PANIC_DIE, "Cannot open %s log file \"%s\": %s: "
 399   "euid=%d egid=%d", log_names[type], buffer, strerror(errno), euid, getegid());
 400 /* Never returns */
 401 }
 402
 403
 404
 405 /*************************************************
 406 *     Add configuration file info to log line    *
 407 *************************************************/
 408
 409 /* This is put in a function because it's needed twice (once for debugging,
 410 once for real).
 411
 412 Arguments:
 413   ptr         pointer to the end of the line we are building
 414   flags       log flags
 415
 416 Returns:      updated pointer
 417 */
 418
 419 static uschar *
 420 log_config_info(uschar *ptr, int flags)
 421 {
 422 Ustrcpy(ptr, "Exim configuration error");
 423 ptr += 24;
 424
 425 if ((flags & (LOG_CONFIG_FOR & ~LOG_CONFIG)) != 0)
 426   {
 427   Ustrcpy(ptr, " for ");
 428   return ptr + 5;
 429   }
 430
 431 if ((flags & (LOG_CONFIG_IN & ~LOG_CONFIG)) != 0)
 432   {
 433   sprintf(CS ptr, " in line %d of %s", config_lineno, config_filename);
 434   while (*ptr) ptr++;
 435   }
 436
 437 Ustrcpy(ptr, ":\n  ");
 438 return ptr + 4;
 439 }
 440
 441
 442 /*************************************************
 443 *           A write() operation failed           *
 444 *************************************************/
 445
 446 /* This function is called when write() fails on anything other than the panic
 447 log, which can happen if a disk gets full or a file gets too large or whatever.
 448 We try to save the relevant message in the panic_save buffer before crashing
 449 out.
 450
 451 Arguments:
 452   name      the name of the log being written
 453   length    the string length being written
 454   rc        the return value from write()
 455
 456 Returns:    does not return
 457 */
 458
 459 static void
 460 log_write_failed(uschar *name, int length, int rc)
 461 {
 462 int save_errno = errno;
 463
 464 if (panic_save_buffer == NULL)
 465   {
 466   panic_save_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
 467   if (panic_save_buffer != NULL)
 468     memcpy(panic_save_buffer, log_buffer, LOG_BUFFER_SIZE);
 469   }
 470
 471 log_write(0, LOG_PANIC_DIE, "failed to write to %s: length=%d result=%d "
 472   "errno=%d (%s)", name, length, rc, save_errno,
 473   (save_errno == 0)? "write incomplete" : strerror(save_errno));
 474 /* Never returns */
 475 }
 476
 477
 478
 479 /*************************************************
 480 *            Write message to log file           *
 481 *************************************************/
 482
 483 /* Exim can be configured to log to local files, or use syslog, or both. This
 484 is controlled by the setting of log_file_path. The following cases are
 485 recognized:
 486
 487   log_file_path = ""               write files in the spool/log directory
 488   log_file_path = "xxx"            write files in the xxx directory
 489   log_file_path = "syslog"         write to syslog
 490   log_file_path = "syslog : xxx"   write to syslog and to files (any order)
 491
 492 The one exception to this is messages containing LOG_PROCESS. These are always
 493 written to exim-process.info in the spool directory. They aren't really log
 494 messages in the same sense as the others.
 495
 496 The message always gets '\n' added on the end of it, since more than one
 497 process may be writing to the log at once and we don't want intermingling to
 498 happen in the middle of lines. To be absolutely sure of this we write the data
 499 into a private buffer and then put it out in a single write() call.
 500
 501 The flags determine which log(s) the message is written to, or for syslogging,
 502 which priority to use, and in the case of the panic log, whether the process
 503 should die afterwards.
 504
 505 The variable really_exim is TRUE only when exim is running in privileged state
 506 (i.e. not with a changed configuration or with testing options such as -brw).
 507 If it is not, don't try to write to the log because permission will probably be
 508 denied.
 509
 510 Avoid actually writing to the logs when exim is called with -bv or -bt to
 511 test an address, but take other actions, such as panicing.
 512
 513 In Exim proper, the buffer for building the message is got at start-up, so that
 514 nothing gets done if it can't be got. However, some functions that are also
 515 used in utilities occasionally obey log_write calls in error situations, and it
 516 is simplest to put a single malloc() here rather than put one in each utility.
 517 Malloc is used directly because the store functions may call log_write().
 518
 519 If a message_id exists, we include it after the timestamp.
 520
 521 Arguments:
 522   selector  write to main log or LOG_INFO only if this value is zero, or if
 523               its bit is set in log_write_selector
 524   flags     each bit indicates some independent action:
 525               LOG_SENDER      add raw sender to the message
 526               LOG_RECIPIENTS  add raw recipients list to message
 527               LOG_CONFIG      add "Exim configuration error"
 528               LOG_CONFIG_FOR  add " for " instead of ":\n  "
 529               LOG_CONFIG_IN   add " in line x[ of file y]"
 530               LOG_MAIN        write to main log or syslog LOG_INFO
 531               LOG_REJECT      write to reject log or syslog LOG_NOTICE
 532               LOG_PANIC       write to panic log or syslog LOG_ALERT
 533               LOG_PANIC_DIE   write to panic log or LOG_ALERT and then crash
 534               LOG_PROCESS     write to process log (always a file)
 535   format    a printf() format
 536   ...       arguments for format
 537
 538 Returns:    nothing
 539 */
 540
 541 void
 542 log_write(unsigned int selector, int flags, char *format, ...)
 543 {
 544 uschar *ptr;
 545 int length, rc;
 546 int paniclogfd;
 547 va_list ap;
 548
 549 /* If panic_recurseflag is set, we have failed to open the panic log. This is
 550 the ultimate disaster. First try to write the message to a debug file and/or
 551 stderr and also to syslog. If panic_save_buffer is not NULL, it contains the
 552 original log line that caused the problem. Afterwards, expire. */
 553
 554 if (panic_recurseflag)
 555   {
 556   uschar *extra = (panic_save_buffer == NULL)? US"" : panic_save_buffer;
 557   if (debug_file != NULL) debug_printf("%s%s", extra, log_buffer);
 558   if (log_stderr != NULL && log_stderr != debug_file)
 559     fprintf(log_stderr, "%s%s", extra, log_buffer);
 560   if (*extra != 0) write_syslog(LOG_CRIT, extra);
 561   write_syslog(LOG_CRIT, log_buffer);
 562   die(US"exim: could not open panic log - aborting: see message(s) above",
 563     US"Unexpected log failure, please try later");
 564   }
 565
 566 /* Ensure we have a buffer (see comment above); this should never be obeyed
 567 when running Exim proper, only when running utilities. */
 568
 569 if (log_buffer == NULL)
 570   {
 571   log_buffer = (uschar *)malloc(LOG_BUFFER_SIZE);
 572   if (log_buffer == NULL)
 573     {
 574     fprintf(stderr, "exim: failed to get store for log buffer\n");
 575     exim_exit(EXIT_FAILURE);
 576     }
 577   }
 578
 579 /* If we haven't already done so, inspect the setting of log_file_path to
 580 determine whether to log to files and/or to syslog. Bits in logging_mode
 581 control this, and for file logging, the path must end up in file_path. This
 582 variable must be in permanent store because it may be required again later in
 583 the process. */
 584
 585 if (!path_inspected)
 586   {
 587   BOOL multiple = FALSE;
 588   int old_pool = store_pool;
 589
 590   store_pool = POOL_PERM;
 591
 592   /* If nothing has been set, don't waste effort... the default values for the
 593   statics are file_path="" and logging_mode = LOG_MODE_FILE. */
 594
 595   if (log_file_path[0] != 0)
 596     {
 597     int sep = ':';              /* Fixed separator - outside use */
 598     uschar *s;
 599     uschar *ss = log_file_path;
 600     logging_mode = 0;
 601     while ((s = string_nextinlist(&ss,&sep,log_buffer,LOG_BUFFER_SIZE)) != NULL)
 602       {
 603       if (Ustrcmp(s, "syslog") == 0)
 604         logging_mode |= LOG_MODE_SYSLOG;
 605       else if ((logging_mode & LOG_MODE_FILE) != 0) multiple = TRUE;
 606       else
 607         {
 608         logging_mode |= LOG_MODE_FILE;
 609
 610         /* If a non-empty path is given, use it */
 611
 612         if (s[0] != 0)
 613           {
 614           file_path = string_copy(s);
 615           }
 616
 617         /* If the path is empty, we want to use the first non-empty, non-
 618         syslog item in LOG_FILE_PATH, if there is one, since the value of
 619         log_file_path may have been set at runtime. If there is no such item,
 620         use the ultimate default in the spool directory. */
 621
 622         else
 623           {
 624           uschar *t;
 625           uschar *tt = US LOG_FILE_PATH;
 626           while ((t = string_nextinlist(&tt,&sep,log_buffer,LOG_BUFFER_SIZE))
 627                 != NULL)
 628             {
 629             if (Ustrcmp(t, "syslog") == 0 || t[0] == 0) continue;
 630             file_path = string_copy(t);
 631             break;
 632             }
 633           }  /* Empty item in log_file_path */
 634         }    /* First non-syslog item in log_file_path */
 635       }      /* Scan of log_file_path */
 636     }
 637
 638   /* If no modes have been selected, it is a major disaster */
 639
 640   if (logging_mode == 0)
 641     die(US"Neither syslog nor file logging set in log_file_path",
 642         US"Unexpected logging failure");
 643
 644   /* Set up the ultimate default if necessary. Then revert to the old store
 645   pool, and record that we've sorted out the path. */
 646
 647   if ((logging_mode & LOG_MODE_FILE) != 0 && file_path[0] == 0)
 648     file_path = string_sprintf("%s/log/%%slog", spool_directory);
 649   store_pool = old_pool;
 650   path_inspected = TRUE;
 651
 652   /* If more than one file path was given, log a complaint. This recursive call
 653   should work since we have now set up the routing. */
 654
 655   if (multiple)
 656     {
 657     log_write(0, LOG_MAIN|LOG_PANIC,
 658       "More than one path given in log_file_path: using %s", file_path);
 659     }
 660   }
 661
 662 /* If debugging, show all log entries, but don't show headers. Do it all
 663 in one go so that it doesn't get split when multi-processing. */
 664
 665 DEBUG(D_any|D_v)
 666   {
 667   int i;
 668   ptr = log_buffer;
 669
 670   Ustrcpy(ptr, "LOG:");
 671   ptr += 4;
 672
 673   /* Show the options that were passed into the call. These are those whose
 674   flag values do not have the 0x80000000 bit in them. Note that this
 675   automatically exclude the "all" setting. */
 676
 677   for (i = 0; i < log_options_count; i++)
 678     {
 679     unsigned int bit = log_options[i].bit;
 680     if ((bit & 0x80000000) != 0) continue;
 681     if ((selector & bit) != 0)
 682       {
 683       *ptr++ = ' ';
 684       Ustrcpy(ptr, log_options[i].name);
 685       while (*ptr) ptr++;
 686       }
 687     }
 688
 689   sprintf(CS ptr, "%s%s%s%s%s\n  ",
 690     ((flags & LOG_MAIN) != 0)?    " MAIN"   : "",
 691     ((flags & LOG_PANIC) != 0)?   " PANIC"  : "",
 692     ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE)? " DIE" : "",
 693     ((flags & LOG_PROCESS) != 0)? " PROCESS": "",
 694     ((flags & LOG_REJECT) != 0)?  " REJECT" : "");
 695
 696   while(*ptr) ptr++;
 697   if ((flags & LOG_CONFIG) != 0) ptr = log_config_info(ptr, flags);
 698
 699   va_start(ap, format);
 700   if (!string_vformat(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer)-1, format, ap))
 701     Ustrcpy(ptr, "**** log string overflowed log buffer ****");
 702   va_end(ap);
 703
 704   while(*ptr) ptr++;
 705   Ustrcat(ptr, "\n");
 706   debug_printf("%s", log_buffer);
 707   }
 708
 709 /* If no log file is specified, we are in a mess. */
 710
 711 if ((flags & (LOG_MAIN|LOG_PANIC|LOG_REJECT|LOG_PROCESS)) == 0)
 712   log_write(0, LOG_MAIN|LOG_PANIC_DIE, "log_write called with no log "
 713     "flags set");
 714
 715 /* There are some weird circumstances in which logging is disabled. */
 716
 717 if (disable_logging)
 718   {
 719   DEBUG(D_any) debug_printf("log writing disabled\n");
 720   return;
 721   }
 722
 723 /* Create the main message in the log buffer, including the message
 724 id except for the process log and when called by a utility. */
 725
 726 ptr = log_buffer;
 727 if (really_exim && (flags & LOG_PROCESS) == 0 && message_id[0] != 0)
 728   sprintf(CS ptr, "%s %s ", tod_stamp(tod_log), message_id);
 729 else sprintf(CS ptr, "%s ", tod_stamp(tod_log));
 730
 731 while(*ptr) ptr++;
 732 if ((flags & LOG_CONFIG) != 0) ptr = log_config_info(ptr, flags);
 733
 734 va_start(ap, format);
 735 if (!string_vformat(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer)-1, format, ap))
 736   Ustrcpy(ptr, "**** log string overflowed log buffer ****\n");
 737 while(*ptr) ptr++;
 738 va_end(ap);
 739
 740 /* Add the raw, unrewritten, sender to the message if required. This is done
 741 this way because it kind of fits with LOG_RECIPIENTS. */
 742
 743 if ((flags & LOG_SENDER) != 0 &&
 744     ptr < log_buffer + LOG_BUFFER_SIZE - 8 - Ustrlen(raw_sender))
 745   {
 746   sprintf(CS ptr, " from <%s>", raw_sender);
 747   while (*ptr) ptr++;
 748   }
 749
 750 /* Add list of recipients to the message if required; the raw list,
 751 before rewriting, was saved in raw_recipients. There may be none, if an ACL
 752 discarded them all. */
 753
 754 if ((flags & LOG_RECIPIENTS) != 0 && ptr < log_buffer + LOG_BUFFER_SIZE - 6 &&
 755      raw_recipients_count > 0)
 756   {
 757   int i;
 758   sprintf(CS ptr, " for");
 759   while (*ptr) ptr++;
 760   for (i = 0; i < raw_recipients_count; i++)
 761     {
 762     uschar *s = raw_recipients[i];
 763     if (log_buffer + LOG_BUFFER_SIZE - ptr < Ustrlen(s) + 3) break;
 764     sprintf(CS ptr, " %s", s);
 765     while (*ptr) ptr++;
 766     }
 767   }
 768
 769 sprintf(CS  ptr, "\n");
 770 while(*ptr) ptr++;
 771 length = ptr - log_buffer;
 772
 773 /* Handle loggable errors when running a utility, or when address testing.
 774 Write to log_stderr unless debugging (when it will already have been written),
 775 or unless there is no log_stderr (expn called from daemon, for example). */
 776
 777 if (!really_exim || log_testing_mode)
 778   {
 779   if (debug_selector == 0 && log_stderr != NULL &&
 780       (selector == 0 || (selector & log_write_selector) != 0))
 781     {
 782     if (host_checking)
 783       fprintf(log_stderr, "LOG: %s", CS(log_buffer + 20));  /* no timestamp */
 784     else
 785       fprintf(log_stderr, "%s", CS log_buffer);
 786     }
 787   if ((flags & LOG_PANIC_DIE) == LOG_PANIC_DIE) exim_exit(EXIT_FAILURE);
 788   return;
 789   }
 790
 791 /* Handle the main log. We know that either syslog or file logging (or both) is
 792 set up. A real file gets left open during reception or delivery once it has
 793 been opened, but we don't want to keep on writing to it for too long after it
 794 has been renamed. Therefore, do a stat() and see if the inode has changed, and
 795 if so, re-open. */
 796
 797 if ((flags & LOG_MAIN) != 0 &&
 798     (selector == 0 || (selector & log_write_selector) != 0))
 799   {
 800   if ((logging_mode & LOG_MODE_SYSLOG) != 0 &&
 801       (syslog_duplication || (flags & (LOG_REJECT|LOG_PANIC)) == 0))
 802     write_syslog(LOG_INFO, log_buffer);
 803
 804   if ((logging_mode & LOG_MODE_FILE) != 0)
 805     {
 806     struct stat statbuf;
 807
 808     /* Check for a change to the mainlog file name when datestamping is in
 809     operation. This happens at midnight, at which point we want to roll over
 810     the file. Closing it has the desired effect. */
 811
 812     if (mainlog_datestamp != NULL)
 813       {
 814       uschar *nowstamp = tod_stamp(tod_log_datestamp);
 815       if (Ustrncmp (mainlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
 816         {
 817         (void)close(mainlogfd);       /* Close the file */
 818         mainlogfd = -1;               /* Clear the file descriptor */
 819         mainlog_inode = 0;            /* Unset the inode */
 820         mainlog_datestamp = NULL;     /* Clear the datestamp */
 821         }
 822       }
 823
 824     /* Otherwise, we want to check whether the file has been renamed by a
 825     cycling script. This could be "if else", but for safety's sake, leave it as
 826     "if" so that renaming the log starts a new file even when datestamping is
 827     happening. */
 828
 829     if (mainlogfd >= 0)
 830       {
 831       if (Ustat(mainlog_name, &statbuf) < 0 || statbuf.st_ino != mainlog_inode)
 832         {
 833         (void)close(mainlogfd);
 834         mainlogfd = -1;
 835         mainlog_inode = 0;
 836         }
 837       }
 838
 839     /* If the log is closed, open it. Then write the line. */
 840
 841     if (mainlogfd < 0)
 842       {
 843       open_log(&mainlogfd, lt_main);     /* No return on error */
 844       if (fstat(mainlogfd, &statbuf) >= 0) mainlog_inode = statbuf.st_ino;
 845       }
 846
 847     /* Failing to write to the log is disastrous */
 848
 849     if ((rc = write(mainlogfd, log_buffer, length)) != length)
 850       {
 851       log_write_failed(US"main log", length, rc);
 852       /* That function does not return */
 853       }
 854     }
 855   }
 856
 857 /* Handle the log for rejected messages. This can be globally disabled. If
 858 there are any header lines (i.e. if the rejection is happening after the DATA
 859 phase), log the recipients and the headers. */
 860
 861 if (write_rejectlog && (flags & LOG_REJECT) != 0)
 862   {
 863   header_line *h;
 864
 865   if (header_list != NULL && (log_extra_selector & LX_rejected_header) != 0)
 866     {
 867     if (recipients_count > 0)
 868       {
 869       int i;
 870
 871       /* List the sender */
 872
 873       string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 874         "Envelope-from: <%s>\n", sender_address);
 875       while (*ptr) ptr++;
 876
 877       /* List up to 5 recipients */
 878
 879       string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 880         "Envelope-to: <%s>\n", recipients_list[0].address);
 881       while (*ptr) ptr++;
 882
 883       for (i = 1; i < recipients_count && i < 5; i++)
 884         {
 885         string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer), "    <%s>\n",
 886           recipients_list[i].address);
 887         while (*ptr) ptr++;
 888         }
 889
 890       if (i < recipients_count)
 891         {
 892         (void)string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 893           "    ...\n");
 894         while (*ptr) ptr++;
 895         }
 896       }
 897
 898     /* A header with a NULL text is an unfilled in Received: header */
 899
 900     for (h = header_list; h != NULL; h = h->next)
 901       {
 902       BOOL fitted;
 903       if (h->text == NULL) continue;
 904       fitted = string_format(ptr, LOG_BUFFER_SIZE - (ptr-log_buffer),
 905         "%c %s", h->type, h->text);
 906       while(*ptr) ptr++;
 907       if (!fitted)         /* Buffer is full; truncate */
 908         {
 909         ptr -= 100;        /* For message and separator */
 910         if (ptr[-1] == '\n') ptr--;
 911         Ustrcpy(ptr, "\n*** truncated ***\n");
 912         while (*ptr) ptr++;
 913         break;
 914         }
 915       }
 916
 917     length = ptr - log_buffer;
 918     }
 919
 920   /* Write to syslog or to a log file */
 921
 922   if ((logging_mode & LOG_MODE_SYSLOG) != 0 &&
 923       (syslog_duplication || (flags & LOG_PANIC) == 0))
 924     write_syslog(LOG_NOTICE, log_buffer);
 925
 926   /* Check for a change to the rejectlog file name when datestamping is in
 927   operation. This happens at midnight, at which point we want to roll over
 928   the file. Closing it has the desired effect. */
 929
 930   if ((logging_mode & LOG_MODE_FILE) != 0)
 931     {
 932     struct stat statbuf;
 933
 934     if (rejectlog_datestamp != NULL)
 935       {
 936       uschar *nowstamp = tod_stamp(tod_log_datestamp);
 937       if (Ustrncmp (rejectlog_datestamp, nowstamp, Ustrlen(nowstamp)) != 0)
 938         {
 939         (void)close(rejectlogfd);       /* Close the file */
 940         rejectlogfd = -1;               /* Clear the file descriptor */
 941         rejectlog_inode = 0;            /* Unset the inode */
 942         rejectlog_datestamp = NULL;     /* Clear the datestamp */
 943         }
 944       }
 945
 946     /* Otherwise, we want to check whether the file has been renamed by a
 947     cycling script. This could be "if else", but for safety's sake, leave it as
 948     "if" so that renaming the log starts a new file even when datestamping is
 949     happening. */
 950
 951     if (rejectlogfd >= 0)
 952       {
 953       if (Ustat(rejectlog_name, &statbuf) < 0 ||
 954            statbuf.st_ino != rejectlog_inode)
 955         {
 956         (void)close(rejectlogfd);
 957         rejectlogfd = -1;
 958         rejectlog_inode = 0;
 959         }
 960       }
 961
 962     /* Open the file if necessary, and write the data */
 963
 964     if (rejectlogfd < 0)
 965       {
 966       open_log(&rejectlogfd, lt_reject); /* No return on error */
 967       if (fstat(rejectlogfd, &statbuf) >= 0) rejectlog_inode = statbuf.st_ino;
 968       }
 969
 970     if ((rc = write(rejectlogfd, log_buffer, length)) != length)
 971       {
 972       log_write_failed(US"reject log", length, rc);
 973       /* That function does not return */
 974       }
 975     }
 976   }
 977
 978
 979 /* Handle the process log file, where exim processes can be made to dump
 980 details of what they are doing by sending them a USR1 signal. Note that
 981 a message id is not automatically added above. This information is always
 982 written to a file - never to syslog. */
 983
 984 if ((flags & LOG_PROCESS) != 0)
 985   {
 986   int processlogfd;
 987   open_log(&processlogfd, lt_process);  /* No return on error */
 988   if ((rc = write(processlogfd, log_buffer, length)) != length)
 989     {
 990     log_write_failed(US"process log", length, rc);
 991     /* That function does not return */
 992     }
 993   (void)close(processlogfd);
 994   }
 995
 996
 997 /* Handle the panic log, which is not kept open like the others. If it fails to
 998 open, there will be a recursive call to log_write(). We detect this above and
 999 attempt to write to the system log as a last-ditch try at telling somebody. In
1000 all cases except mua_wrapper, try to write to log_stderr. */
1001
1002 if ((flags & LOG_PANIC) != 0)
1003   {
1004   if (log_stderr != NULL && log_stderr != debug_file && !mua_wrapper)
1005     fprintf(log_stderr, "%s", CS log_buffer);
1006
1007   if ((logging_mode & LOG_MODE_SYSLOG) != 0)
1008     {
1009     write_syslog(LOG_ALERT, log_buffer);
1010     }
1011
1012   /* If this panic logging was caused by a failure to open the main log,
1013   the original log line is in panic_save_buffer. Make an attempt to write it. */
1014
1015   if ((logging_mode & LOG_MODE_FILE) != 0)
1016     {
1017     panic_recurseflag = TRUE;
1018     open_log(&paniclogfd, lt_panic);  /* Won't return on failure */
1019     panic_recurseflag = FALSE;
1020
1021     if (panic_save_buffer != NULL)
1022       (void) write(paniclogfd, panic_save_buffer, Ustrlen(panic_save_buffer));
1023
1024     if ((rc = write(paniclogfd, log_buffer, length)) != length)
1025       {
1026       int save_errno = errno;
1027       write_syslog(LOG_CRIT, log_buffer);
1028       sprintf(CS log_buffer, "write failed on panic log: length=%d result=%d "
1029         "errno=%d (%s)", length, rc, save_errno, strerror(save_errno));
1030       write_syslog(LOG_CRIT, log_buffer);
1031       flags |= LOG_PANIC_DIE;
1032       }
1033
1034     (void)close(paniclogfd);
1035     }
1036
1037   /* Give up if the DIE flag is set */
1038
1039   if ((flags & LOG_PANIC_DIE) != LOG_PANIC)
1040     die(NULL, US"Unexpected failure, please try later");
1041   }
1042 }
1043
1044
1045
1046 /*************************************************
1047 *            Close any open log files            *
1048 *************************************************/
1049
1050 void
1051 log_close_all(void)
1052 {
1053 if (mainlogfd >= 0)
1054   { (void)close(mainlogfd); mainlogfd = -1; }
1055 if (rejectlogfd >= 0)
1056   { (void)close(rejectlogfd); rejectlogfd = -1; }
1057 closelog();
1058 syslog_open = FALSE;
1059 }
1060
1061 /* End of log.c */