X-Git-Url: https://git.exim.org/users/heiko/exim.git/blobdiff_plain/1ba28e2b955b005ce4825fec792df17f75a8de1e..f60d98e8a1d3f9ca2805fdeee7c8062b44c5362d:/src/src/exim.c?ds=inline diff --git a/src/src/exim.c b/src/src/exim.c index f086a00e8..a59cfea9a 100644 --- a/src/src/exim.c +++ b/src/src/exim.c @@ -1,10 +1,8 @@ -/* $Cambridge: exim/src/src/exim.c,v 1.71 2010/06/07 00:12:42 pdp Exp $ */ - /************************************************* * Exim - an Internet mail transport agent * *************************************************/ -/* Copyright (c) University of Cambridge 1995 - 2009 */ +/* Copyright (c) University of Cambridge 1995 - 2012 */ /* See the file NOTICE for conditions of use and distribution. */ @@ -54,6 +52,16 @@ store_free(block); +/************************************************* +* Enums for cmdline interface * +*************************************************/ + +enum commandline_info { CMDINFO_NONE=0, + CMDINFO_HELP, CMDINFO_SIEVE, CMDINFO_DSCP }; + + + + /************************************************* * Compile regular expression and panic on fail * *************************************************/ @@ -140,6 +148,38 @@ return yield; +/************************************************* +* Set up processing details * +*************************************************/ + +/* Save a text string for dumping when SIGUSR1 is received. +Do checks for overruns. + +Arguments: format and arguments, as for printf() +Returns: nothing +*/ + +void +set_process_info(const char *format, ...) +{ +int len; +va_list ap; +sprintf(CS process_info, "%5d ", (int)getpid()); +len = Ustrlen(process_info); +va_start(ap, format); +if (!string_vformat(process_info + len, PROCESS_INFO_SIZE - len - 2, format, ap)) + Ustrcpy(process_info + len, "**** string overflowed buffer ****"); +len = Ustrlen(process_info); +process_info[len+0] = '\n'; +process_info[len+1] = '\0'; +process_info_len = len + 1; +DEBUG(D_process_info) debug_printf("set_process_info: %s", process_info); +va_end(ap); +} + + + + /************************************************* * Handler for SIGUSR1 * *************************************************/ @@ -149,6 +189,8 @@ what it is currently doing. It will only be used if the OS is capable of setting up a handler that causes automatic restarting of any system call that is in progress at the time. +This function takes care to be signal-safe. + Argument: the signal number (SIGUSR1) Returns: nothing */ @@ -156,10 +198,32 @@ Returns: nothing static void usr1_handler(int sig) { -sig = sig; /* Keep picky compilers happy */ -log_write(0, LOG_PROCESS, "%s", process_info); -log_close_all(); -os_restarting_signal(SIGUSR1, usr1_handler); +int fd; + +os_restarting_signal(sig, usr1_handler); + +fd = Uopen(process_log_path, O_APPEND|O_WRONLY, LOG_MODE); +if (fd < 0) + { + /* If we are already running as the Exim user, try to create it in the + current process (assuming spool_directory exists). Otherwise, if we are + root, do the creation in an exim:exim subprocess. */ + + int euid = geteuid(); + if (euid == exim_uid) + fd = Uopen(process_log_path, O_CREAT|O_APPEND|O_WRONLY, LOG_MODE); + else if (euid == root_uid) + fd = log_create_as_exim(process_log_path); + } + +/* If we are neither exim nor root, or if we failed to create the log file, +give up. There is not much useful we can do with errors, since we don't want +to disrupt whatever is going on outside the signal handler. */ + +if (fd < 0) return; + +(void)write(fd, process_info, process_info_len); +(void)close(fd); } @@ -348,35 +412,6 @@ if (exim_tvcmp(&now_tv, then_tv) <= 0) -/************************************************* -* Set up processing details * -*************************************************/ - -/* Save a text string for dumping when SIGUSR1 is received. -Do checks for overruns. - -Arguments: format and arguments, as for printf() -Returns: nothing -*/ - -void -set_process_info(const char *format, ...) -{ -int len; -va_list ap; -sprintf(CS process_info, "%5d ", (int)getpid()); -len = Ustrlen(process_info); -va_start(ap, format); -if (!string_vformat(process_info + len, PROCESS_INFO_SIZE - len, format, ap)) - Ustrcpy(process_info + len, "**** string overflowed buffer ****"); -DEBUG(D_process_info) debug_printf("set_process_info: %s\n", process_info); -va_end(ap); -} - - - - - /************************************************* * Call fopen() with umask 777 and adjust mode * *************************************************/ @@ -491,7 +526,7 @@ close_unwanted(void) if (smtp_input) { #ifdef SUPPORT_TLS - tls_close(FALSE); /* Shut down the TLS library */ + tls_close(FALSE, FALSE); /* Shut down the TLS library */ #endif (void)close(fileno(smtp_in)); (void)close(fileno(smtp_out)); @@ -700,6 +735,8 @@ Returns: nothing static void show_whats_supported(FILE *f) { + auth_info *authi; + #ifdef DB_VERSION_STRING fprintf(f, "Berkeley DB: %s\n", DB_VERSION_STRING); #elif defined(BTREEVERSION) && defined(HASHVERSION) @@ -789,7 +826,7 @@ fprintf(f, "Lookups (built-in):"); fprintf(f, " cdb"); #endif #if defined(LOOKUP_DBM) && LOOKUP_DBM!=2 - fprintf(f, " dbm dbmnz"); + fprintf(f, " dbm dbmjz dbmnz"); #endif #if defined(LOOKUP_DNSDB) && LOOKUP_DNSDB!=2 fprintf(f, " dnsdb"); @@ -842,6 +879,12 @@ fprintf(f, "Authenticators:"); #ifdef AUTH_DOVECOT fprintf(f, " dovecot"); #endif +#ifdef AUTH_GSASL + fprintf(f, " gsasl"); +#endif +#ifdef AUTH_HEIMDAL_GSSAPI + fprintf(f, " heimdal_gssapi"); +#endif #ifdef AUTH_PLAINTEXT fprintf(f, " plaintext"); #endif @@ -912,36 +955,52 @@ if (fixed_never_users[0] > 0) fprintf(f, "Size of off_t: " SIZE_T_FMT "\n", sizeof(off_t)); -/* This runtime check is to help diagnose library linkage mismatches which -result in segfaults and the like; as such, it's left until the end, -just in case. There will still be a "Configuration file is" line still to -come. */ -#ifdef SUPPORT_TLS -tls_version_report(f); -#endif - /* Everything else is details which are only worth reporting when debugging. Perhaps the tls_version_report should move into this too. */ DEBUG(D_any) do { int i; -#ifdef AUTH_CYRUS_SASL - auth_cyrus_sasl_version_report(f); +/* clang defines __GNUC__ (at least, for me) so test for it first */ +#if defined(__clang__) + fprintf(f, "Compiler: CLang [%s]\n", __clang_version__); +#elif defined(__GNUC__) + fprintf(f, "Compiler: GCC [%s]\n", +# ifdef __VERSION__ + __VERSION__ +# else + "? unknown version ?" +# endif + ); +#else + fprintf(f, "Compiler: \n"); +#endif + +#ifdef SUPPORT_TLS + tls_version_report(f); #endif + for (authi = auths_available; *authi->driver_name != '\0'; ++authi) { + if (authi->version_report) { + (*authi->version_report)(f); + } + } + + /* PCRE_PRERELEASE is either defined and empty or a bare sequence of + characters; unless it's an ancient version of PCRE in which case it + is not defined. */ +#ifndef PCRE_PRERELEASE +#define PCRE_PRERELEASE +#endif +#define QUOTE(X) #X +#define EXPAND_AND_QUOTE(X) QUOTE(X) fprintf(f, "Library version: PCRE: Compile: %d.%d%s\n" " Runtime: %s\n", PCRE_MAJOR, PCRE_MINOR, - /* PRE_PRERELEASE is either defined and empty or a string. - * unless its an ancient version of PCRE in which case it - * is not defined */ -#ifdef PCRE_PRERELEASE - PCRE_PRERELEASE "", -#else - "", -#endif + EXPAND_AND_QUOTE(PCRE_PRERELEASE) "", pcre_version()); +#undef QUOTE +#undef EXPAND_AND_QUOTE init_lookup_list(); for (i = 0; i < lookup_list_count; i++) @@ -965,6 +1024,39 @@ DEBUG(D_any) do { } +/************************************************* +* Show auxiliary information about Exim * +*************************************************/ + +static void +show_exim_information(enum commandline_info request, FILE *stream) +{ +const uschar **pp; + +switch(request) + { + case CMDINFO_NONE: + fprintf(stream, "Oops, something went wrong.\n"); + return; + case CMDINFO_HELP: + fprintf(stream, +"The -bI: flag takes a string indicating which information to provide.\n" +"If the string is not recognised, you'll get this help (on stderr).\n" +"\n" +" exim -bI:help this information\n" +" exim -bI:dscp dscp value keywords known\n" +" exim -bI:sieve list of supported sieve extensions, one per line.\n" +); + return; + case CMDINFO_SIEVE: + for (pp = exim_sieve_extension_list; *pp; ++pp) + fprintf(stream, "%s\n", *pp); + return; + case CMDINFO_DSCP: + dscp_list_to_stream(stream); + return; + } +} /************************************************* @@ -1042,9 +1134,9 @@ set_readline(char * (**fn_readline_ptr)(const char *), void (**fn_addhist_ptr)(const char *)) { void *dlhandle; -void *dlhandle_curses = dlopen("libcurses.so", RTLD_GLOBAL|RTLD_LAZY); +void *dlhandle_curses = dlopen("libcurses." DYNLIB_FN_EXT, RTLD_GLOBAL|RTLD_LAZY); -dlhandle = dlopen("libreadline.so", RTLD_GLOBAL|RTLD_NOW); +dlhandle = dlopen("libreadline." DYNLIB_FN_EXT, RTLD_GLOBAL|RTLD_NOW); if (dlhandle_curses != NULL) dlclose(dlhandle_curses); if (dlhandle != NULL) @@ -1288,7 +1380,7 @@ for (m = macros; m != NULL; m = m->next) return FALSE; } } -DEBUG(D_any) debug_printf("macros_trusted overriden to true by whitelisting\n"); +DEBUG(D_any) debug_printf("macros_trusted overridden to true by whitelisting\n"); return TRUE; #endif } @@ -1342,6 +1434,8 @@ BOOL checking = FALSE; BOOL count_queue = FALSE; BOOL expansion_test = FALSE; BOOL extract_recipients = FALSE; +BOOL flag_G = FALSE; +BOOL flag_n = FALSE; BOOL forced_delivery = FALSE; BOOL f_end_dot = FALSE; BOOL deliver_give_up = FALSE; @@ -1362,6 +1456,7 @@ BOOL verify_as_sender = FALSE; BOOL version_printed = FALSE; uschar *alias_arg = NULL; uschar *called_as = US""; +uschar *cmdline_syslog_name = NULL; uschar *start_queue_run_id = NULL; uschar *stop_queue_run_id = NULL; uschar *expansion_test_message = NULL; @@ -1372,6 +1467,7 @@ uschar *ftest_suffix = NULL; uschar *malware_test_file = NULL; uschar *real_sender_address; uschar *originator_home = US"/"; +size_t sz; void *reset_point; struct passwd *pw; @@ -1380,6 +1476,10 @@ pid_t passed_qr_pid = (pid_t)0; int passed_qr_pipe = -1; gid_t group_list[NGROUPS_MAX]; +/* For the -bI: flag */ +enum commandline_info info_flag = CMDINFO_NONE; +BOOL info_stdout = FALSE; + /* Possible options for -R and -S */ static uschar *rsopts[] = { US"f", US"ff", US"r", US"rf", US"rff" }; @@ -1403,7 +1503,19 @@ if (route_finduser(US EXIM_USERNAME, &pw, &exim_uid)) EXIM_USERNAME); exit(EXIT_FAILURE); } - exim_gid = pw->pw_gid; + /* If ref:name uses a number as the name, route_finduser() returns + TRUE with exim_uid set and pw coerced to NULL. */ + if (pw) + exim_gid = pw->pw_gid; +#ifndef EXIM_GROUPNAME + else + { + fprintf(stderr, + "exim: ref:name should specify a usercode, not a group.\n" + "exim: can't let you get away with it unless you also specify a group.\n"); + exit(EXIT_FAILURE); + } +#endif } else { @@ -1766,6 +1878,26 @@ for (i = 1; i < argc; i++) switch(switchchar) { + + /* sendmail uses -Ac and -Am to control which .cf file is used; + we ignore them. */ + case 'A': + if (*argrest == '\0') { badarg = TRUE; break; } + else + { + BOOL ignore = FALSE; + switch (*argrest) + { + case 'c': + case 'm': + if (*(argrest + 1) == '\0') + ignore = TRUE; + break; + } + if (!ignore) { badarg = TRUE; break; } + } + break; + /* -Btype is a sendmail option for 7bit/8bit setting. Exim is 8-bit clean so has no need of it. */ @@ -1867,6 +1999,32 @@ for (i = 1; i < argc; i++) else if (Ustrcmp(argrest, "i") == 0) bi_option = TRUE; + /* -bI: provide information, of the type to follow after a colon. + This is an Exim flag. */ + + else if (argrest[0] == 'I' && Ustrlen(argrest) >= 2 && argrest[1] == ':') + { + uschar *p = &argrest[2]; + info_flag = CMDINFO_HELP; + if (Ustrlen(p)) + { + if (strcmpic(p, CUS"sieve") == 0) + { + info_flag = CMDINFO_SIEVE; + info_stdout = TRUE; + } + else if (strcmpic(p, CUS"dscp") == 0) + { + info_flag = CMDINFO_DSCP; + info_stdout = TRUE; + } + else if (strcmpic(p, CUS"help") == 0) + { + info_stdout = TRUE; + } + } + } + /* -bm: Accept and deliver message - the default option. Reinstate receiving_message, which got turned off for all -b options. */ @@ -2000,6 +2158,24 @@ for (i = 1; i < argc; i++) show_whats_supported(stdout); } + /* -bw: inetd wait mode, accept a listening socket as stdin */ + + else if (*argrest == 'w') + { + inetd_wait_mode = TRUE; + background_daemon = FALSE; + daemon_listen = TRUE; + if (*(++argrest) != '\0') + { + inetd_wait_timeout = readconf_readtime(argrest, 0, FALSE); + if (inetd_wait_timeout <= 0) + { + fprintf(stderr, "exim: bad time value %s: abandoned\n", argv[i]); + exit(EXIT_FAILURE); + } + } + } + else badarg = TRUE; break; @@ -2331,9 +2507,13 @@ for (i = 1; i < argc; i++) } break; - /* This is some Sendmail thing which can be ignored */ + /* -G: sendmail invocation to specify that it's a gateway submission and + sendmail may complain about problems instead of fixing them. + We make it equivalent to an ACL "control = suppress_local_fixups" and do + not at this time complain about problems. */ case 'G': + flag_G = TRUE; break; /* -h: Set the hop count for an incoming message. Exim does not currently @@ -2358,6 +2538,29 @@ for (i = 1; i < argc; i++) break; + /* -L: set the identifier used for syslog; equivalent to setting + syslog_processname in the config file, but needs to be an admin option. */ + + case 'L': + if (*argrest == '\0') + { + if(++i < argc) argrest = argv[i]; else + { badarg = TRUE; break; } + } + sz = Ustrlen(argrest); + if (sz > 32) + { + fprintf(stderr, "exim: the -L syslog name is too long: \"%s\"\n", argrest); + return EXIT_FAILURE; + } + if (sz < 1) + { + fprintf(stderr, "exim: the -L syslog name is too short\n"); + return EXIT_FAILURE; + } + cmdline_syslog_name = argrest; + break; + case 'M': receiving_message = FALSE; @@ -2620,10 +2823,12 @@ for (i = 1; i < argc; i++) break; - /* -n: This means "don't alias" in sendmail, apparently. Just ignore - it. */ + /* -n: This means "don't alias" in sendmail, apparently. + For normal invocations, it has no effect. + It may affect some other options. */ case 'n': + flag_n = TRUE; break; /* -O: Just ignore it. In sendmail, apparently -O option=value means set @@ -3071,7 +3276,7 @@ for (i = 1; i < argc; i++) /* -tls-on-connect: don't wait for STARTTLS (for old clients) */ #ifdef SUPPORT_TLS - else if (Ustrcmp(argrest, "ls-on-connect") == 0) tls_on_connect = TRUE; + else if (Ustrcmp(argrest, "ls-on-connect") == 0) tls_in.on_connect = TRUE; #endif else badarg = TRUE; @@ -3112,6 +3317,20 @@ for (i = 1; i < argc; i++) if (*argrest != 0) badarg = TRUE; break; + /* -X: in sendmail: takes one parameter, logfile, and sends debugging + logs to that file. We swallow the parameter and otherwise ignore it. */ + + case 'X': + if (*argrest == '\0') + { + if (++i >= argc) + { + fprintf(stderr, "exim: string expected after -X\n"); + exit(EXIT_FAILURE); + } + } + break; + /* All other initial characters are errors */ default: @@ -3162,6 +3381,9 @@ if (( daemon_listen && queue_interval == 0 ) || ( + inetd_wait_mode && queue_interval >= 0 + ) || + ( list_options && (checking || smtp_input || extract_recipients || filter_test != FTEST_NONE || bi_option) @@ -3396,12 +3618,83 @@ if ((filter_test & FTEST_USER) != 0) } } +/* Initialise lookup_list +If debugging, already called above via version reporting. +In either case, we initialise the list of available lookups while running +as root. All dynamically modules are loaded from a directory which is +hard-coded into the binary and is code which, if not a module, would be +part of Exim already. Ability to modify the content of the directory +is equivalent to the ability to modify a setuid binary! + +This needs to happen before we read the main configuration. */ +init_lookup_list(); + /* Read the main runtime configuration data; this gives up if there is a failure. It leaves the configuration file open so that the subsequent configuration data for delivery can be read if needed. */ readconf_main(); +/* If an action on specific messages is requested, or if a daemon or queue +runner is being started, we need to know if Exim was called by an admin user. +This is the case if the real user is root or exim, or if the real group is +exim, or if one of the supplementary groups is exim or a group listed in +admin_groups. We don't fail all message actions immediately if not admin_user, +since some actions can be performed by non-admin users. Instead, set admin_user +for later interrogation. */ + +if (real_uid == root_uid || real_uid == exim_uid || real_gid == exim_gid) + admin_user = TRUE; +else + { + int i, j; + for (i = 0; i < group_count; i++) + { + if (group_list[i] == exim_gid) admin_user = TRUE; + else if (admin_groups != NULL) + { + for (j = 1; j <= (int)(admin_groups[0]); j++) + if (admin_groups[j] == group_list[i]) + { admin_user = TRUE; break; } + } + if (admin_user) break; + } + } + +/* Another group of privileged users are the trusted users. These are root, +exim, and any caller matching trusted_users or trusted_groups. Trusted callers +are permitted to specify sender_addresses with -f on the command line, and +other message parameters as well. */ + +if (real_uid == root_uid || real_uid == exim_uid) + trusted_caller = TRUE; +else + { + int i, j; + + if (trusted_users != NULL) + { + for (i = 1; i <= (int)(trusted_users[0]); i++) + if (trusted_users[i] == real_uid) + { trusted_caller = TRUE; break; } + } + + if (!trusted_caller && trusted_groups != NULL) + { + for (i = 1; i <= (int)(trusted_groups[0]); i++) + { + if (trusted_groups[i] == real_gid) + trusted_caller = TRUE; + else for (j = 0; j < group_count; j++) + { + if (trusted_groups[i] == group_list[j]) + { trusted_caller = TRUE; break; } + } + if (trusted_caller) break; + } + } + } + /* Handle the decoding of logging options. */ decode_bits(&log_write_selector, &log_extra_selector, 0, 0, @@ -3433,6 +3726,24 @@ if (sender_address != NULL) } } +/* See if an admin user overrode our logging. */ + +if (cmdline_syslog_name != NULL) + { + if (admin_user) + { + syslog_processname = cmdline_syslog_name; + log_file_path = string_copy(CUS"syslog"); + } + else + { + /* not a panic, non-privileged users should not be able to spam paniclog */ + fprintf(stderr, + "exim: you lack sufficient privilege to specify syslog process name\n"); + return EXIT_FAILURE; + } + } + /* Paranoia check of maximum lengths of certain strings. There is a check on the length of the log file path in log.c, which will come into effect if there are any calls to write the log earlier than this. However, if we @@ -3584,13 +3895,6 @@ if (opt_perl_at_start && opt_perl_startup != NULL) } #endif /* EXIM_PERL */ -/* Initialise lookup_list -If debugging, already called above via version reporting. -This does mean that debugging causes the list to be initialised while root. -This *should* be harmless -- all modules are loaded from a fixed dir and -it's code that would, if not a module, be part of Exim already. */ -init_lookup_list(); - /* Log the arguments of the call if the configuration file said so. This is a debugging feature for finding out what arguments certain MUAs actually use. Don't attempt it if logging is disabled, or if listing variables or if @@ -3683,65 +3987,9 @@ if (bi_option) } } -/* If an action on specific messages is requested, or if a daemon or queue -runner is being started, we need to know if Exim was called by an admin user. -This is the case if the real user is root or exim, or if the real group is -exim, or if one of the supplementary groups is exim or a group listed in -admin_groups. We don't fail all message actions immediately if not admin_user, -since some actions can be performed by non-admin users. Instead, set admin_user -for later interrogation. */ - -if (real_uid == root_uid || real_uid == exim_uid || real_gid == exim_gid) - admin_user = TRUE; -else - { - int i, j; - for (i = 0; i < group_count; i++) - { - if (group_list[i] == exim_gid) admin_user = TRUE; - else if (admin_groups != NULL) - { - for (j = 1; j <= (int)(admin_groups[0]); j++) - if (admin_groups[j] == group_list[i]) - { admin_user = TRUE; break; } - } - if (admin_user) break; - } - } - -/* Another group of privileged users are the trusted users. These are root, -exim, and any caller matching trusted_users or trusted_groups. Trusted callers -are permitted to specify sender_addresses with -f on the command line, and -other message parameters as well. */ - -if (real_uid == root_uid || real_uid == exim_uid) - trusted_caller = TRUE; -else - { - int i, j; - - if (trusted_users != NULL) - { - for (i = 1; i <= (int)(trusted_users[0]); i++) - if (trusted_users[i] == real_uid) - { trusted_caller = TRUE; break; } - } - - if (!trusted_caller && trusted_groups != NULL) - { - for (i = 1; i <= (int)(trusted_groups[0]); i++) - { - if (trusted_groups[i] == real_gid) - trusted_caller = TRUE; - else for (j = 0; j < group_count; j++) - { - if (trusted_groups[i] == group_list[j]) - { trusted_caller = TRUE; break; } - } - if (trusted_caller) break; - } - } - } +/* We moved the admin/trusted check to be immediately after reading the +configuration file. We leave these prints here to ensure that syslog setup, +logfile setup, and so on has already happened. */ if (trusted_caller) DEBUG(D_any) debug_printf("trusted user\n"); if (admin_user) DEBUG(D_any) debug_printf("admin user\n"); @@ -3809,6 +4057,21 @@ else interface_port = check_port(interface_address); } +/* If the caller is trusted, then they can use -G to suppress_local_fixups. */ +if (flag_G) + { + if (trusted_caller) + { + suppress_local_fixups = suppress_local_fixups_default = TRUE; + DEBUG(D_acl) debug_printf("suppress_local_fixups forced on by -G\n"); + } + else + { + fprintf(stderr, "exim: permission denied (-G requires a trusted user)\n"); + return EXIT_FAILURE; + } + } + /* If an SMTP message is being received check to see if the standard input is a TCP/IP socket. If it is, we assume that Exim was called from inetd if the caller is root or the Exim user, or if the port is a privileged one. Otherwise, @@ -3830,7 +4093,7 @@ if (smtp_input) interface_address = host_ntoa(-1, &interface_sock, NULL, &interface_port); - if (host_is_tls_on_connect_port(interface_port)) tls_on_connect = TRUE; + if (host_is_tls_on_connect_port(interface_port)) tls_in.on_connect = TRUE; if (real_uid == root_uid || real_uid == exim_uid || interface_port < 1024) { @@ -4137,11 +4400,12 @@ if (test_retry_arg >= 0) } /* Handle a request to list one or more configuration options */ +/* If -n was set, we suppress some information */ if (list_options) { set_process_info("listing variables"); - if (recipients_arg >= argc) readconf_print(US"all", NULL); + if (recipients_arg >= argc) readconf_print(US"all", NULL, flag_n); else for (i = recipients_arg; i < argc; i++) { if (i < argc - 1 && @@ -4150,10 +4414,10 @@ if (list_options) Ustrcmp(argv[i], "authenticator") == 0 || Ustrcmp(argv[i], "macro") == 0)) { - readconf_print(argv[i+1], argv[i]); + readconf_print(argv[i+1], argv[i], flag_n); i++; } - else readconf_print(argv[i], NULL); + else readconf_print(argv[i], NULL, flag_n); } exim_exit(EXIT_SUCCESS); } @@ -4342,7 +4606,7 @@ returns. We leave this till here so that the originator_ fields are available for incoming messages via the daemon. The daemon cannot be run in mua_wrapper mode. */ -if (daemon_listen || queue_interval > 0) +if (daemon_listen || inetd_wait_mode || queue_interval > 0) { if (mua_wrapper) { @@ -4680,7 +4944,8 @@ if (host_checking) /* Arrange for message reception if recipients or SMTP were specified; otherwise complain unless a version print (-bV) happened or this is a filter -verification test. In the former case, show the configuration file name. */ +verification test or info dump. +In the former case, show the configuration file name. */ if (recipients_arg >= argc && !extract_recipients && !smtp_input) { @@ -4690,6 +4955,12 @@ if (recipients_arg >= argc && !extract_recipients && !smtp_input) return EXIT_SUCCESS; } + if (info_flag != CMDINFO_NONE) + { + show_exim_information(info_flag, info_stdout ? stdout : stderr); + return info_stdout ? EXIT_SUCCESS : EXIT_FAILURE; + } + if (filter_test == FTEST_NONE) exim_usage(called_as); }