# endif
#endif
+#ifndef _TIME_H
+# include <time.h>
+#endif
+
extern void init_lookup_list(void);
static void *
function_store_get(size_t size)
{
-return store_get((int)size);
+/* For now, regard all RE results as potentially tainted. We might need
+more intelligence on this point. */
+return store_get((int)size, TRUE);
}
static void
pcre_free = function_store_free;
}
if (caseless) options |= PCRE_CASELESS;
-yield = pcre_compile(CCS pattern, options, (const char **)&error, &offset, NULL);
+yield = pcre_compile(CCS pattern, options, CCSS &error, &offset, NULL);
pcre_malloc = function_store_get;
pcre_free = function_dummy_free;
if (yield == NULL)
int ovector[3*(EXPAND_MAXN+1)];
uschar * s = string_copy(subject); /* de-constifying */
int n = pcre_exec(re, NULL, CS s, Ustrlen(s), 0,
- PCRE_EOPT | options, ovector, sizeof(ovector)/sizeof(int));
+ PCRE_EOPT | options, ovector, nelem(ovector));
BOOL yield = n >= 0;
if (n == 0) n = EXPAND_MAXN + 1;
if (yield)
{
- int nn;
- expand_nmax = (setup < 0)? 0 : setup + 1;
- for (nn = (setup < 0)? 0 : 2; nn < n*2; nn += 2)
+ expand_nmax = setup < 0 ? 0 : setup + 1;
+ for (int nn = setup < 0 ? 0 : 2; nn < n*2; nn += 2)
{
expand_nstring[expand_nmax] = s + ovector[nn];
expand_nlength[expand_nmax++] = ovector[nn+1] - ovector[nn];
void
set_process_info(const char *format, ...)
{
-int len = sprintf(CS process_info, "%5d ", (int)getpid());
+gstring gs = { .size = PROCESS_INFO_SIZE - 2, .ptr = 0, .s = process_info };
+gstring * g;
+int len;
va_list ap;
+
+g = string_fmt_append(&gs, "%5d ", (int)getpid());
+len = g->ptr;
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;
+if (!string_vformat(g, 0, format, ap))
+ {
+ gs.ptr = len;
+ g = string_cat(&gs, US"**** string overflowed buffer ****");
+ }
+g = string_catn(g, US"\n", 1);
+string_from_gstring(g);
+process_info_len = g->ptr;
DEBUG(D_process_info) debug_printf("set_process_info: %s", process_info);
va_end(ap);
}
static void
term_handler(int sig)
{
- exit(1);
+exit(1);
}
when a bug in a function that calls milliwait() caused it to pass invalid data.
That's when I added the check. :-)
-We assume it to be not worth sleeping for under 100us; this value will
+We assume it to be not worth sleeping for under 50us; this value will
require revisiting as hardware advances. This avoids the issue of
a zero-valued timer setting meaning "never fire".
{
sigset_t sigmask;
sigset_t old_sigmask;
+int save_errno = errno;
-if (itval->it_value.tv_usec < 100 && itval->it_value.tv_sec == 0)
+if (itval->it_value.tv_usec < 50 && itval->it_value.tv_sec == 0)
return;
(void)sigemptyset(&sigmask); /* Empty mask */
(void)sigaddset(&sigmask, SIGALRM); /* Add SIGALRM */
(void)sigdelset(&sigmask, SIGALRM); /* Remove SIGALRM */
(void)sigsuspend(&sigmask); /* Until SIGALRM */
(void)sigprocmask(SIG_SETMASK, &old_sigmask, NULL); /* Restore mask */
+errno = save_errno;
+sigalrm_seen = FALSE;
}
void
millisleep(int msec)
{
-struct itimerval itval;
-itval.it_interval.tv_sec = 0;
-itval.it_interval.tv_usec = 0;
-itval.it_value.tv_sec = msec/1000;
-itval.it_value.tv_usec = (msec % 1000) * 1000;
+struct itimerval itval = {.it_interval = {.tv_sec = 0, .tv_usec = 0},
+ .it_value = {.tv_sec = msec/1000,
+ .tv_usec = (msec % 1000) * 1000}};
milliwait(&itval);
}
* Clock tick wait function *
*************************************************/
+#ifdef _POSIX_MONOTONIC_CLOCK
+/* Amount CLOCK_MONOTONIC is behind realtime, at startup. */
+static struct timespec offset_ts;
+
+static void
+exim_clock_init(void)
+{
+struct timeval tv;
+if (clock_gettime(CLOCK_MONOTONIC, &offset_ts) != 0) return;
+(void)gettimeofday(&tv, NULL);
+offset_ts.tv_sec = tv.tv_sec - offset_ts.tv_sec;
+offset_ts.tv_nsec = tv.tv_usec * 1000 - offset_ts.tv_nsec;
+if (offset_ts.tv_nsec >= 0) return;
+offset_ts.tv_sec--;
+offset_ts.tv_nsec += 1000*1000*1000;
+}
+#endif
+
+
/* Exim uses a time + a pid to generate a unique identifier in two places: its
message IDs, and in file names for maildir deliveries. Because some OS now
re-use pids within the same second, sub-second times are now being used.
clocks that go backwards.
Arguments:
- then_tv A timeval which was used to create uniqueness; its usec field
+ tgt_tv A timeval which was used to create uniqueness; its usec field
has been rounded down to the value of the resolution.
We want to be sure the current time is greater than this.
resolution The resolution that was used to divide the microseconds
*/
void
-exim_wait_tick(struct timeval *then_tv, int resolution)
+exim_wait_tick(struct timeval * tgt_tv, int resolution)
{
struct timeval now_tv;
long int now_true_usec;
-(void)gettimeofday(&now_tv, NULL);
-now_true_usec = now_tv.tv_usec;
-now_tv.tv_usec = (now_true_usec/resolution) * resolution;
+#ifdef _POSIX_MONOTONIC_CLOCK
+struct timespec now_ts;
-if (exim_tvcmp(&now_tv, then_tv) <= 0)
+if (clock_gettime(CLOCK_MONOTONIC, &now_ts) == 0)
+ {
+ now_ts.tv_sec += offset_ts.tv_sec;
+ if ((now_ts.tv_nsec += offset_ts.tv_nsec) >= 1000*1000*1000)
+ {
+ now_ts.tv_sec++;
+ now_ts.tv_nsec -= 1000*1000*1000;
+ }
+ now_tv.tv_sec = now_ts.tv_sec;
+ now_true_usec = (now_ts.tv_nsec / (resolution * 1000)) * resolution;
+ now_tv.tv_usec = now_true_usec;
+ }
+else
+#endif
+ {
+ (void)gettimeofday(&now_tv, NULL);
+ now_true_usec = now_tv.tv_usec;
+ now_tv.tv_usec = (now_true_usec/resolution) * resolution;
+ }
+
+while (exim_tvcmp(&now_tv, tgt_tv) <= 0)
{
struct itimerval itval;
itval.it_interval.tv_sec = 0;
itval.it_interval.tv_usec = 0;
- itval.it_value.tv_sec = then_tv->tv_sec - now_tv.tv_sec;
- itval.it_value.tv_usec = then_tv->tv_usec + resolution - now_true_usec;
+ itval.it_value.tv_sec = tgt_tv->tv_sec - now_tv.tv_sec;
+ itval.it_value.tv_usec = tgt_tv->tv_usec + resolution - now_true_usec;
/* We know that, overall, "now" is less than or equal to "then". Therefore, a
negative value for the microseconds is possible only in the case when "now"
- is more than a second less than "then". That means that itval.it_value.tv_sec
+ is more than a second less than "tgt". That means that itval.it_value.tv_sec
is greater than zero. The following correction is therefore safe. */
if (itval.it_value.tv_usec < 0)
DEBUG(D_transport|D_receive)
{
- if (!running_in_test_harness)
+ if (!f.running_in_test_harness)
{
debug_printf("tick check: " TIME_T_FMT ".%06lu " TIME_T_FMT ".%06lu\n",
- then_tv->tv_sec, (long) then_tv->tv_usec,
+ tgt_tv->tv_sec, (long) tgt_tv->tv_usec,
now_tv.tv_sec, (long) now_tv.tv_usec);
- debug_printf("waiting " TIME_T_FMT ".%06lu\n",
+ debug_printf("waiting " TIME_T_FMT ".%06lu sec\n",
itval.it_value.tv_sec, (long) itval.it_value.tv_usec);
}
}
milliwait(&itval);
+
+ /* Be prapared to go around if the kernel does not implement subtick
+ granularity (GNU Hurd) */
+
+ (void)gettimeofday(&now_tv, NULL);
+ now_true_usec = now_tv.tv_usec;
+ now_tv.tv_usec = (now_true_usec/resolution) * resolution;
}
}
}
-
-
/*************************************************
* Ensure stdin, stdout, and stderr exist *
*************************************************/
void
exim_nullstd(void)
{
-int i;
int devnull = -1;
struct stat statbuf;
-for (i = 0; i <= 2; i++)
+for (int i = 0; i <= 2; i++)
{
if (fstat(i, &statbuf) < 0 && errno == EBADF)
{
if (devnull < 0) devnull = open("/dev/null", O_RDWR);
if (devnull < 0) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "%s",
- string_open_failed(errno, "/dev/null"));
+ string_open_failed(errno, "/dev/null", NULL));
if (devnull != i) (void)dup2(devnull, i);
}
}
{
if (smtp_input)
{
-#ifdef SUPPORT_TLS
+#ifndef DISABLE_TLS
tls_close(NULL, TLS_NO_SHUTDOWN); /* Shut down the TLS library */
#endif
(void)close(fileno(smtp_in));
if ((debug_selector & D_resolver) == 0) (void)close(1); /* stdout */
if (debug_selector == 0) /* stderr */
{
- if (!synchronous_delivery)
+ if (!f.synchronous_delivery)
{
(void)close(2);
log_stderr = NULL;
if (igflag)
{
struct passwd *pw = getpwuid(uid);
- if (pw != NULL)
- {
- if (initgroups(pw->pw_name, gid) != 0)
- log_write(0,LOG_MAIN|LOG_PANIC_DIE,"initgroups failed for uid=%ld: %s",
- (long int)uid, strerror(errno));
- }
- else log_write(0, LOG_MAIN|LOG_PANIC_DIE, "cannot run initgroups(): "
- "no passwd entry for uid=%ld", (long int)uid);
+ if (!pw)
+ log_write(0, LOG_MAIN|LOG_PANIC_DIE, "cannot run initgroups(): "
+ "no passwd entry for uid=%ld", (long int)uid);
+
+ if (initgroups(pw->pw_name, gid) != 0)
+ log_write(0,LOG_MAIN|LOG_PANIC_DIE,"initgroups failed for uid=%ld: %s",
+ (long int)uid, strerror(errno));
}
if (setgid(gid) < 0 || setuid(uid) < 0)
- {
log_write(0, LOG_MAIN|LOG_PANIC_DIE, "unable to set gid=%ld or uid=%ld "
"(euid=%ld): %s", (long int)gid, (long int)uid, (long int)euid, msg);
- }
}
/* Debugging output included uid/gid and all groups */
DEBUG(D_uid)
{
int group_count, save_errno;
- gid_t group_list[NGROUPS_MAX];
+ gid_t group_list[EXIM_GROUPLIST_SIZE];
debug_printf("changed uid/gid: %s\n uid=%ld gid=%ld pid=%ld\n", msg,
(long int)geteuid(), (long int)getegid(), (long int)getpid());
- group_count = getgroups(NGROUPS_MAX, group_list);
+ group_count = getgroups(nelem(group_list), group_list);
save_errno = errno;
debug_printf(" auxiliary group list:");
if (group_count > 0)
- {
- int i;
- for (i = 0; i < group_count; i++) debug_printf(" %d", (int)group_list[i]);
- }
+ for (int i = 0; i < group_count; i++) debug_printf(" %d", (int)group_list[i]);
else if (group_count < 0)
debug_printf(" <error: %s>", strerror(save_errno));
else debug_printf(" <none>");
exim_exit(int rc, const uschar * process)
{
search_tidyup();
+store_exit();
DEBUG(D_any)
debug_printf(">>>>>>>>>>>>>>>> Exim pid=%d %s%s%sterminating with rc=%d "
">>>>>>>>>>>>>>>>\n", (int)getpid(),
}
+void
+exim_underbar_exit(int rc, const uschar * process)
+{
+store_exit();
+DEBUG(D_any)
+ debug_printf(">>>>>>>>>>>>>>>> Exim pid=%d %s%s%sterminating with rc=%d "
+ ">>>>>>>>>>>>>>>>\n", (int)getpid(),
+ process ? "(" : "", process, process ? ") " : "", rc);
+_exit(rc);
+}
+
+
+
+/* Print error string, then die */
+static void
+exim_fail(const char * fmt, ...)
+{
+va_list ap;
+va_start(ap, fmt);
+vfprintf(stderr, fmt, ap);
+exit(EXIT_FAILURE);
+}
+
+/* exim_chown_failure() called from exim_chown()/exim_fchown() on failure
+of chown()/fchown(). See src/functions.h for more explanation */
+int
+exim_chown_failure(int fd, const uschar *name, uid_t owner, gid_t group)
+{
+int saved_errno = errno; /* from the preceeding chown call */
+#if 1
+log_write(0, LOG_MAIN|LOG_PANIC,
+ __FILE__ ":%d: chown(%s, %d:%d) failed (%s)."
+ " Please contact the authors and refer to https://bugs.exim.org/show_bug.cgi?id=2391",
+ __LINE__, name?name:US"<unknown>", owner, group, strerror(errno));
+#else
+/* I leave this here, commented, in case the "bug"(?) comes up again.
+ It is not an Exim bug, but we can provide a workaround.
+ See Bug 2391
+ HS 2019-04-18 */
+
+struct stat buf;
+
+if (0 == (fd < 0 ? stat(name, &buf) : fstat(fd, &buf)))
+{
+ if (buf.st_uid == owner && buf.st_gid == group) return 0;
+ log_write(0, LOG_MAIN|LOG_PANIC, "Wrong ownership on %s", name);
+}
+else log_write(0, LOG_MAIN|LOG_PANIC, "Stat failed on %s: %s", name, strerror(errno));
+
+#endif
+errno = saved_errno;
+return -1;
+}
/*************************************************
{
int port = host_address_extract_port(address);
if (string_is_ip_address(address, NULL) == 0)
- {
- fprintf(stderr, "exim abandoned: \"%s\" is not an IP address\n", address);
- exit(EXIT_FAILURE);
- }
+ exim_fail("exim abandoned: \"%s\" is not an IP address\n", address);
return port;
}
*/
static void
-show_whats_supported(FILE * f)
+show_whats_supported(FILE * fp)
{
-auth_info * authi;
-
-DEBUG(D_any) {} else show_db_version(f);
+DEBUG(D_any) {} else show_db_version(fp);
-fprintf(f, "Support for:");
+fprintf(fp, "Support for:");
#ifdef SUPPORT_CRYPTEQ
- fprintf(f, " crypteq");
+ fprintf(fp, " crypteq");
#endif
#if HAVE_ICONV
- fprintf(f, " iconv()");
+ fprintf(fp, " iconv()");
#endif
#if HAVE_IPV6
- fprintf(f, " IPv6");
+ fprintf(fp, " IPv6");
#endif
#ifdef HAVE_SETCLASSRESOURCES
- fprintf(f, " use_setclassresources");
+ fprintf(fp, " use_setclassresources");
#endif
#ifdef SUPPORT_PAM
- fprintf(f, " PAM");
+ fprintf(fp, " PAM");
#endif
#ifdef EXIM_PERL
- fprintf(f, " Perl");
+ fprintf(fp, " Perl");
#endif
#ifdef EXPAND_DLFUNC
- fprintf(f, " Expand_dlfunc");
+ fprintf(fp, " Expand_dlfunc");
#endif
#ifdef USE_TCP_WRAPPERS
- fprintf(f, " TCPwrappers");
+ fprintf(fp, " TCPwrappers");
#endif
-#ifdef SUPPORT_TLS
-# ifdef USE_GNUTLS
- fprintf(f, " GnuTLS");
-# else
- fprintf(f, " OpenSSL");
-# endif
+#ifdef USE_GNUTLS
+ fprintf(fp, " GnuTLS");
+#endif
+#ifdef USE_OPENSSL
+ fprintf(fp, " OpenSSL");
#endif
#ifdef SUPPORT_TRANSLATE_IP_ADDRESS
- fprintf(f, " translate_ip_address");
+ fprintf(fp, " translate_ip_address");
#endif
#ifdef SUPPORT_MOVE_FROZEN_MESSAGES
- fprintf(f, " move_frozen_messages");
+ fprintf(fp, " move_frozen_messages");
#endif
#ifdef WITH_CONTENT_SCAN
- fprintf(f, " Content_Scanning");
+ fprintf(fp, " Content_Scanning");
#endif
#ifdef SUPPORT_DANE
- fprintf(f, " DANE");
+ fprintf(fp, " DANE");
#endif
#ifndef DISABLE_DKIM
- fprintf(f, " DKIM");
+ fprintf(fp, " DKIM");
#endif
#ifndef DISABLE_DNSSEC
- fprintf(f, " DNSSEC");
+ fprintf(fp, " DNSSEC");
#endif
#ifndef DISABLE_EVENT
- fprintf(f, " Event");
+ fprintf(fp, " Event");
#endif
#ifdef SUPPORT_I18N
- fprintf(f, " I18N");
+ fprintf(fp, " I18N");
#endif
#ifndef DISABLE_OCSP
- fprintf(f, " OCSP");
+ fprintf(fp, " OCSP");
+#endif
+#ifndef DISABLE_PIPE_CONNECT
+ fprintf(fp, " PIPE_CONNECT");
#endif
#ifndef DISABLE_PRDR
- fprintf(f, " PRDR");
+ fprintf(fp, " PRDR");
#endif
#ifdef SUPPORT_PROXY
- fprintf(f, " PROXY");
+ fprintf(fp, " PROXY");
#endif
#ifdef SUPPORT_SOCKS
- fprintf(f, " SOCKS");
+ fprintf(fp, " SOCKS");
#endif
#ifdef SUPPORT_SPF
- fprintf(f, " SPF");
+ fprintf(fp, " SPF");
#endif
-#ifdef TCP_FASTOPEN
- deliver_init();
- if (tcp_fastopen_ok) fprintf(f, " TCP_Fast_Open");
+#ifdef SUPPORT_DMARC
+ fprintf(fp, " DMARC");
#endif
-#ifdef EXPERIMENTAL_LMDB
- fprintf(f, " Experimental_LMDB");
-#endif
-#ifdef EXPERIMENTAL_QUEUEFILE
- fprintf(f, " Experimental_QUEUEFILE");
-#endif
-#ifdef EXPERIMENTAL_SRS
- fprintf(f, " Experimental_SRS");
+#ifdef TCP_FASTOPEN
+ tcp_init();
+ if (f.tcp_fastopen_ok) fprintf(fp, " TCP_Fast_Open");
#endif
#ifdef EXPERIMENTAL_ARC
- fprintf(f, " Experimental_ARC");
+ fprintf(fp, " Experimental_ARC");
#endif
#ifdef EXPERIMENTAL_BRIGHTMAIL
- fprintf(f, " Experimental_Brightmail");
+ fprintf(fp, " Experimental_Brightmail");
#endif
#ifdef EXPERIMENTAL_DCC
- fprintf(f, " Experimental_DCC");
-#endif
-#ifdef EXPERIMENTAL_DMARC
- fprintf(f, " Experimental_DMARC");
+ fprintf(fp, " Experimental_DCC");
#endif
#ifdef EXPERIMENTAL_DSN_INFO
- fprintf(f, " Experimental_DSN_info");
+ fprintf(fp, " Experimental_DSN_info");
+#endif
+#ifdef EXPERIMENTAL_LMDB
+ fprintf(fp, " Experimental_LMDB");
+#endif
+#ifdef EXPERIMENTAL_QUEUE_RAMP
+ fprintf(fp, " Experimental_Queue_Ramp");
+#endif
+#ifdef EXPERIMENTAL_QUEUEFILE
+ fprintf(fp, " Experimental_QUEUEFILE");
+#endif
+#if defined(EXPERIMENTAL_SRS) || defined(EXPERIMENTAL_SRS_NATIVE)
+ fprintf(fp, " Experimental_SRS");
+#endif
+#ifdef EXPERIMENTAL_TLS_RESUME
+ fprintf(fp, " Experimental_TLS_resume");
#endif
-fprintf(f, "\n");
+fprintf(fp, "\n");
-fprintf(f, "Lookups (built-in):");
+fprintf(fp, "Lookups (built-in):");
#if defined(LOOKUP_LSEARCH) && LOOKUP_LSEARCH!=2
- fprintf(f, " lsearch wildlsearch nwildlsearch iplsearch");
+ fprintf(fp, " lsearch wildlsearch nwildlsearch iplsearch");
#endif
#if defined(LOOKUP_CDB) && LOOKUP_CDB!=2
- fprintf(f, " cdb");
+ fprintf(fp, " cdb");
#endif
#if defined(LOOKUP_DBM) && LOOKUP_DBM!=2
- fprintf(f, " dbm dbmjz dbmnz");
+ fprintf(fp, " dbm dbmjz dbmnz");
#endif
#if defined(LOOKUP_DNSDB) && LOOKUP_DNSDB!=2
- fprintf(f, " dnsdb");
+ fprintf(fp, " dnsdb");
#endif
#if defined(LOOKUP_DSEARCH) && LOOKUP_DSEARCH!=2
- fprintf(f, " dsearch");
+ fprintf(fp, " dsearch");
#endif
#if defined(LOOKUP_IBASE) && LOOKUP_IBASE!=2
- fprintf(f, " ibase");
+ fprintf(fp, " ibase");
+#endif
+#if defined(LOOKUP_JSON) && LOOKUP_JSON!=2
+ fprintf(fp, " json");
#endif
#if defined(LOOKUP_LDAP) && LOOKUP_LDAP!=2
- fprintf(f, " ldap ldapdn ldapm");
+ fprintf(fp, " ldap ldapdn ldapm");
#endif
#ifdef EXPERIMENTAL_LMDB
- fprintf(f, " lmdb");
+ fprintf(fp, " lmdb");
#endif
#if defined(LOOKUP_MYSQL) && LOOKUP_MYSQL!=2
- fprintf(f, " mysql");
+ fprintf(fp, " mysql");
#endif
#if defined(LOOKUP_NIS) && LOOKUP_NIS!=2
- fprintf(f, " nis nis0");
+ fprintf(fp, " nis nis0");
#endif
#if defined(LOOKUP_NISPLUS) && LOOKUP_NISPLUS!=2
- fprintf(f, " nisplus");
+ fprintf(fp, " nisplus");
#endif
#if defined(LOOKUP_ORACLE) && LOOKUP_ORACLE!=2
- fprintf(f, " oracle");
+ fprintf(fp, " oracle");
#endif
#if defined(LOOKUP_PASSWD) && LOOKUP_PASSWD!=2
- fprintf(f, " passwd");
+ fprintf(fp, " passwd");
#endif
#if defined(LOOKUP_PGSQL) && LOOKUP_PGSQL!=2
- fprintf(f, " pgsql");
+ fprintf(fp, " pgsql");
#endif
#if defined(LOOKUP_REDIS) && LOOKUP_REDIS!=2
- fprintf(f, " redis");
+ fprintf(fp, " redis");
#endif
#if defined(LOOKUP_SQLITE) && LOOKUP_SQLITE!=2
- fprintf(f, " sqlite");
+ fprintf(fp, " sqlite");
#endif
#if defined(LOOKUP_TESTDB) && LOOKUP_TESTDB!=2
- fprintf(f, " testdb");
+ fprintf(fp, " testdb");
#endif
#if defined(LOOKUP_WHOSON) && LOOKUP_WHOSON!=2
- fprintf(f, " whoson");
+ fprintf(fp, " whoson");
#endif
-fprintf(f, "\n");
+fprintf(fp, "\n");
-auth_show_supported(f);
-route_show_supported(f);
-transport_show_supported(f);
+auth_show_supported(fp);
+route_show_supported(fp);
+transport_show_supported(fp);
#ifdef WITH_CONTENT_SCAN
-malware_show_supported(f);
+malware_show_supported(fp);
#endif
if (fixed_never_users[0] > 0)
{
int i;
- fprintf(f, "Fixed never_users: ");
+ fprintf(fp, "Fixed never_users: ");
for (i = 1; i <= (int)fixed_never_users[0] - 1; i++)
- fprintf(f, "%d:", (unsigned int)fixed_never_users[i]);
- fprintf(f, "%d\n", (unsigned int)fixed_never_users[i]);
+ fprintf(fp, "%d:", (unsigned int)fixed_never_users[i]);
+ fprintf(fp, "%d\n", (unsigned int)fixed_never_users[i]);
}
-fprintf(f, "Configure owner: %d:%d\n", config_uid, config_gid);
+fprintf(fp, "Configure owner: %d:%d\n", config_uid, config_gid);
-fprintf(f, "Size of off_t: " SIZE_T_FMT "\n", sizeof(off_t));
+fprintf(fp, "Size of off_t: " SIZE_T_FMT "\n", sizeof(off_t));
/* 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;
-
/* clang defines __GNUC__ (at least, for me) so test for it first */
#if defined(__clang__)
- fprintf(f, "Compiler: CLang [%s]\n", __clang_version__);
+ fprintf(fp, "Compiler: CLang [%s]\n", __clang_version__);
#elif defined(__GNUC__)
- fprintf(f, "Compiler: GCC [%s]\n",
+ fprintf(fp, "Compiler: GCC [%s]\n",
# ifdef __VERSION__
__VERSION__
# else
# endif
);
#else
- fprintf(f, "Compiler: <unknown>\n");
+ fprintf(fp, "Compiler: <unknown>\n");
#endif
#if defined(__GLIBC__) && !defined(__UCLIBC__)
- fprintf(f, "Library version: Glibc: Compile: %d.%d\n",
+ fprintf(fp, "Library version: Glibc: Compile: %d.%d\n",
__GLIBC__, __GLIBC_MINOR__);
if (__GLIBC_PREREQ(2, 1))
- fprintf(f, " Runtime: %s\n",
+ fprintf(fp, " Runtime: %s\n",
gnu_get_libc_version());
#endif
-show_db_version(f);
+show_db_version(fp);
-#ifdef SUPPORT_TLS
- tls_version_report(f);
+#ifndef DISABLE_TLS
+ tls_version_report(fp);
#endif
#ifdef SUPPORT_I18N
- utf8_version_report(f);
+ utf8_version_report(fp);
+#endif
+#ifdef SUPPORT_SPF
+ spf_lib_version_report(fp);
#endif
- for (authi = auths_available; *authi->driver_name != '\0'; ++authi)
+ for (auth_info * authi = auths_available; *authi->driver_name != '\0'; ++authi)
if (authi->version_report)
- (*authi->version_report)(f);
+ (*authi->version_report)(fp);
/* 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
#endif
#define QUOTE(X) #X
#define EXPAND_AND_QUOTE(X) QUOTE(X)
- fprintf(f, "Library version: PCRE: Compile: %d.%d%s\n"
+ fprintf(fp, "Library version: PCRE: Compile: %d.%d%s\n"
" Runtime: %s\n",
PCRE_MAJOR, PCRE_MINOR,
EXPAND_AND_QUOTE(PCRE_PRERELEASE) "",
#undef EXPAND_AND_QUOTE
init_lookup_list();
- for (i = 0; i < lookup_list_count; i++)
+ for (int i = 0; i < lookup_list_count; i++)
if (lookup_list[i]->version_report)
- lookup_list[i]->version_report(f);
+ lookup_list[i]->version_report(fp);
#ifdef WHITELIST_D_MACROS
- fprintf(f, "WHITELIST_D_MACROS: \"%s\"\n", WHITELIST_D_MACROS);
+ fprintf(fp, "WHITELIST_D_MACROS: \"%s\"\n", WHITELIST_D_MACROS);
#else
- fprintf(f, "WHITELIST_D_MACROS unset\n");
+ fprintf(fp, "WHITELIST_D_MACROS unset\n");
#endif
#ifdef TRUSTED_CONFIG_LIST
- fprintf(f, "TRUSTED_CONFIG_LIST: \"%s\"\n", TRUSTED_CONFIG_LIST);
+ fprintf(fp, "TRUSTED_CONFIG_LIST: \"%s\"\n", TRUSTED_CONFIG_LIST);
#else
- fprintf(f, "TRUSTED_CONFIG_LIST unset\n");
+ fprintf(fp, "TRUSTED_CONFIG_LIST unset\n");
#endif
} while (0);
static void
show_exim_information(enum commandline_info request, FILE *stream)
{
-const uschar **pp;
-
switch(request)
{
case CMDINFO_NONE:
);
return;
case CMDINFO_SIEVE:
- for (pp = exim_sieve_extension_list; *pp; ++pp)
+ for (const uschar ** pp = exim_sieve_extension_list; *pp; ++pp)
fprintf(stream, "%s\n", *pp);
return;
case CMDINFO_DSCP:
{
BOOL needs_quote = FALSE;
gstring * g;
-uschar *t;
-for (t = lpart; !needs_quote && *t != 0; t++)
+for (uschar * t = lpart; !needs_quote && *t != 0; t++)
{
needs_quote = !isalnum(*t) && strchr("!#$%&'*+-/=?^_`{|}~", *t) == NULL &&
(*t != '.' || t == lpart || t[1] == 0);
void *dlhandle_curses = dlopen("libcurses." DYNLIB_FN_EXT, RTLD_GLOBAL|RTLD_LAZY);
dlhandle = dlopen("libreadline." DYNLIB_FN_EXT, RTLD_GLOBAL|RTLD_NOW);
-if (dlhandle_curses != NULL) dlclose(dlhandle_curses);
+if (dlhandle_curses) dlclose(dlhandle_curses);
-if (dlhandle != NULL)
+if (dlhandle)
{
/* Checked manual pages; at least in GNU Readline 6.1, the prototypes are:
* char * readline (const char *prompt);
*fn_addhist_ptr = (void(*)(const char*))dlsym(dlhandle, "add_history");
}
else
- {
DEBUG(D_any) debug_printf("failed to load readline: %s\n", dlerror());
- }
return dlhandle;
}
static uschar *
get_stdinput(char *(*fn_readline)(const char *), void(*fn_addhist)(const char *))
{
-int i;
gstring * g = NULL;
if (!fn_readline) { printf("> "); fflush(stdout); }
-for (i = 0;; i++)
+for (int i = 0;; i++)
{
uschar buffer[1024];
uschar *p, *ss;
#ifdef USE_READLINE
char *readline_line = NULL;
- if (fn_readline != NULL)
+ if (fn_readline)
{
- if ((readline_line = fn_readline((i > 0)? "":"> ")) == NULL) break;
- if (*readline_line != 0 && fn_addhist != NULL) fn_addhist(readline_line);
+ if (!(readline_line = fn_readline((i > 0)? "":"> "))) break;
+ if (*readline_line != 0 && fn_addhist) fn_addhist(readline_line);
p = US readline_line;
}
else
while (ss > p && isspace(ss[-1])) ss--;
if (i > 0)
- {
while (p < ss && isspace(*p)) p++; /* leading space after cont */
- }
g = string_catn(g, p, ss - p);
/* Handle specific program invocation variants */
if (Ustrcmp(progname, US"-mailq") == 0)
- {
- fprintf(stderr,
+ exim_fail(
"mailq - list the contents of the mail queue\n\n"
"For a list of options, see the Exim documentation.\n");
- exit(EXIT_FAILURE);
- }
/* Generic usage - we output this whatever happens */
-fprintf(stderr,
+exim_fail(
"Exim is a Mail Transfer Agent. It is normally called by Mail User Agents,\n"
"not directly from a shell command line. Options and/or arguments control\n"
"what it does when called. For a list of options, see the Exim documentation.\n");
-
-exit(EXIT_FAILURE);
}
macros_trusted(BOOL opt_D_used)
{
#ifdef WHITELIST_D_MACROS
-macro_item *m;
-uschar *whitelisted, *end, *p, **whites, **w;
+uschar *whitelisted, *end, *p, **whites;
int white_count, i, n;
size_t len;
BOOL prev_char_item, found;
}
/* Get a list of macros which are whitelisted */
-whitelisted = string_copy_malloc(US WHITELIST_D_MACROS);
+whitelisted = string_copy_perm(US WHITELIST_D_MACROS, FALSE);
prev_char_item = FALSE;
white_count = 0;
for (p = whitelisted; *p != '\0'; ++p)
/* The list of commandline macros should be very short.
Accept the N*M complexity. */
-for (m = macros_user; m; m = m->next) if (m->command_line)
+for (macro_item * m = macros_user; m; m = m->next) if (m->command_line)
{
found = FALSE;
- for (w = whites; *w; ++w)
+ for (uschar ** w = whites; *w; ++w)
if (Ustrcmp(*w, m->name) == 0)
{
found = TRUE;
}
+
/*************************************************
* Entry point and high-level code *
*************************************************/
int sender_address_domain = 0;
int test_retry_arg = -1;
int test_rewrite_arg = -1;
+gid_t original_egid;
BOOL arg_queue_only = FALSE;
BOOL bi_option = FALSE;
BOOL checking = FALSE;
uschar *real_sender_address;
uschar *originator_home = US"/";
size_t sz;
-void *reset_point;
+rmark reset_point;
struct passwd *pw;
struct stat statbuf;
pid_t passed_qr_pid = (pid_t)0;
int passed_qr_pipe = -1;
-gid_t group_list[NGROUPS_MAX];
+gid_t group_list[EXIM_GROUPLIST_SIZE];
/* For the -bI: flag */
enum commandline_info info_flag = CMDINFO_NONE;
extern char **environ;
+#ifdef MEASURE_TIMING
+(void)gettimeofday(×tamp_startup, NULL);
+#endif
+
/* If the Exim user and/or group and/or the configuration file owner/group were
defined by ref:name at build time, we must now find the actual uid/gid values.
This is a feature to make the lives of binary distributors easier. */
if (route_finduser(US EXIM_USERNAME, &pw, &exim_uid))
{
if (exim_uid == 0)
- {
- fprintf(stderr, "exim: refusing to run with uid 0 for \"%s\"\n",
- EXIM_USERNAME);
- exit(EXIT_FAILURE);
- }
+ exim_fail("exim: refusing to run with uid 0 for \"%s\"\n", EXIM_USERNAME);
+
/* 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_fail(
"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
- {
- fprintf(stderr, "exim: failed to find uid for user name \"%s\"\n",
- EXIM_USERNAME);
- exit(EXIT_FAILURE);
- }
+ exim_fail("exim: failed to find uid for user name \"%s\"\n", EXIM_USERNAME);
#endif
#ifdef EXIM_GROUPNAME
if (!route_findgroup(US EXIM_GROUPNAME, &exim_gid))
- {
- fprintf(stderr, "exim: failed to find gid for group name \"%s\"\n",
- EXIM_GROUPNAME);
- exit(EXIT_FAILURE);
- }
+ exim_fail("exim: failed to find gid for group name \"%s\"\n", EXIM_GROUPNAME);
#endif
#ifdef CONFIGURE_OWNERNAME
if (!route_finduser(US CONFIGURE_OWNERNAME, NULL, &config_uid))
- {
- fprintf(stderr, "exim: failed to find uid for user name \"%s\"\n",
+ exim_fail("exim: failed to find uid for user name \"%s\"\n",
CONFIGURE_OWNERNAME);
- exit(EXIT_FAILURE);
- }
#endif
/* We default the system_filter_user to be the Exim run-time user, as a
#ifdef CONFIGURE_GROUPNAME
if (!route_findgroup(US CONFIGURE_GROUPNAME, &config_gid))
- {
- fprintf(stderr, "exim: failed to find gid for group name \"%s\"\n",
+ exim_fail("exim: failed to find gid for group name \"%s\"\n",
CONFIGURE_GROUPNAME);
- exit(EXIT_FAILURE);
- }
#endif
/* In the Cygwin environment, some initialization used to need doing.
/* Check a field which is patched when we are running Exim within its
testing harness; do a fast initial check, and then the whole thing. */
-running_in_test_harness =
+f.running_in_test_harness =
*running_status == '<' && Ustrcmp(running_status, "<<<testing>>>") == 0;
-if (running_in_test_harness)
+if (f.running_in_test_harness)
debug_store = TRUE;
/* The C standard says that the equivalent of setlocale(LC_ALL, "C") is obeyed
setlocale(LC_ALL, "C");
+/* Get the offset between CLOCK_MONOTONIC and wallclock */
+
+#ifdef _POSIX_MONOTONIC_CLOCK
+exim_clock_init();
+#endif
+
/* Set up the default handler for timing using alarm(). */
os_non_restarting_signal(SIGALRM, sigalrm_handler);
because store_malloc writes a log entry on failure. */
if (!(log_buffer = US malloc(LOG_BUFFER_SIZE)))
- {
- fprintf(stderr, "exim: failed to get store for log buffer\n");
- exit(EXIT_FAILURE);
- }
+ exim_fail("exim: failed to get store for log buffer\n");
/* Initialize the default log options. */
/* Set up the handler for the data request signal, and set the initial
descriptive text. */
+process_info = store_get(PROCESS_INFO_SIZE, TRUE); /* tainted */
set_process_info("initializing");
os_restarting_signal(SIGUSR1, usr1_handler);
if ((namelen == 5 && Ustrcmp(argv[0], "rmail") == 0) ||
(namelen > 5 && Ustrncmp(argv[0] + namelen - 6, "/rmail", 6) == 0))
{
- dot_ends = FALSE;
+ f.dot_ends = FALSE;
called_as = US"-rmail";
errors_sender_rc = EXIT_SUCCESS;
}
normally be root, but in some esoteric environments it may not be. */
original_euid = geteuid();
+original_egid = getegid();
/* Get the real uid and gid. If the caller is root, force the effective uid/gid
to be the same as the real ones. This makes a difference only if Exim is setuid
if (real_uid == root_uid)
{
- rv = setgid(real_gid);
- if (rv)
- {
- fprintf(stderr, "exim: setgid(%ld) failed: %s\n",
+ if ((rv = setgid(real_gid)))
+ exim_fail("exim: setgid(%ld) failed: %s\n",
(long int)real_gid, strerror(errno));
- exit(EXIT_FAILURE);
- }
- rv = setuid(real_uid);
- if (rv)
- {
- fprintf(stderr, "exim: setuid(%ld) failed: %s\n",
+ if ((rv = setuid(real_uid)))
+ exim_fail("exim: setuid(%ld) failed: %s\n",
(long int)real_uid, strerror(errno));
- exit(EXIT_FAILURE);
- }
}
/* If neither the original real uid nor the original euid was root, Exim is
{
switchchar = arg[3];
argrest += 2;
- queue_2stage = TRUE;
+ f.queue_2stage = TRUE;
}
/* Make -r synonymous with -f, since it is a documented alias */
ignore = TRUE;
break;
}
- if (!ignore) { badarg = TRUE; break; }
+ if (!ignore) badarg = TRUE;
}
break;
so has no need of it. */
case 'B':
- if (*argrest == 0) i++; /* Skip over the type */
+ if (!*argrest) i++; /* Skip over the type */
break;
case 'b':
- receiving_message = FALSE; /* Reset TRUE for -bm, -bS, -bs below */
-
- /* -bd: Run in daemon mode, awaiting SMTP connections.
- -bdf: Ditto, but in the foreground.
- */
-
- if (*argrest == 'd')
- {
- daemon_listen = TRUE;
- if (*(++argrest) == 'f') background_daemon = FALSE;
- else if (*argrest != 0) { badarg = TRUE; break; }
- }
-
- /* -be: Run in expansion test mode
- -bem: Ditto, but read a message from a file first
- */
-
- else if (*argrest == 'e')
- {
- expansion_test = checking = TRUE;
- if (argrest[1] == 'm')
- {
- if (++i >= argc) { badarg = TRUE; break; }
- expansion_test_message = argv[i];
- argrest++;
- }
- if (argrest[1] != 0) { badarg = TRUE; break; }
- }
-
- /* -bF: Run system filter test */
-
- else if (*argrest == 'F')
- {
- filter_test |= checking = FTEST_SYSTEM;
- if (*(++argrest) != 0) { badarg = TRUE; break; }
- if (++i < argc) filter_test_sfile = argv[i]; else
- {
- fprintf(stderr, "exim: file name expected after %s\n", argv[i-1]);
- exit(EXIT_FAILURE);
- }
- }
-
- /* -bf: Run user filter test
- -bfd: Set domain for filter testing
- -bfl: Set local part for filter testing
- -bfp: Set prefix for filter testing
- -bfs: Set suffix for filter testing
- */
-
- else if (*argrest == 'f')
- {
- if (*(++argrest) == 0)
- {
- filter_test |= checking = FTEST_USER;
- if (++i < argc) filter_test_ufile = argv[i]; else
- {
- fprintf(stderr, "exim: file name expected after %s\n", argv[i-1]);
- exit(EXIT_FAILURE);
- }
- }
- else
- {
- if (++i >= argc)
- {
- fprintf(stderr, "exim: string expected after %s\n", arg);
- exit(EXIT_FAILURE);
- }
- if (Ustrcmp(argrest, "d") == 0) ftest_domain = argv[i];
- else if (Ustrcmp(argrest, "l") == 0) ftest_localpart = argv[i];
- else if (Ustrcmp(argrest, "p") == 0) ftest_prefix = argv[i];
- else if (Ustrcmp(argrest, "s") == 0) ftest_suffix = argv[i];
- else { badarg = TRUE; break; }
- }
- }
-
- /* -bh: Host checking - an IP address must follow. */
-
- else if (Ustrcmp(argrest, "h") == 0 || Ustrcmp(argrest, "hc") == 0)
- {
- if (++i >= argc) { badarg = TRUE; break; }
- sender_host_address = argv[i];
- host_checking = checking = log_testing_mode = TRUE;
- host_checking_callout = argrest[1] == 'c';
- message_logs = FALSE;
- }
-
- /* -bi: This option is used by sendmail to initialize *the* alias file,
- though it has the -oA option to specify a different file. Exim has no
- concept of *the* alias file, but since Sun's YP make script calls
- sendmail this way, some support must be provided. */
-
- 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. */
-
- else if (Ustrcmp(argrest, "m") == 0) receiving_message = TRUE;
-
- /* -bmalware: test the filename given for malware */
-
- else if (Ustrcmp(argrest, "malware") == 0)
- {
- if (++i >= argc) { badarg = TRUE; break; }
- checking = TRUE;
- malware_test_file = argv[i];
- }
-
- /* -bnq: For locally originating messages, do not qualify unqualified
- addresses. In the envelope, this causes errors; in header lines they
- just get left. */
-
- else if (Ustrcmp(argrest, "nq") == 0)
- {
- allow_unqualified_sender = FALSE;
- allow_unqualified_recipient = FALSE;
- }
-
- /* -bpxx: List the contents of the mail queue, in various forms. If
- the option is -bpc, just a queue count is needed. Otherwise, if the
- first letter after p is r, then order is random. */
-
- else if (*argrest == 'p')
- {
- if (*(++argrest) == 'c')
- {
- count_queue = TRUE;
- if (*(++argrest) != 0) badarg = TRUE;
- break;
- }
+ receiving_message = FALSE; /* Reset TRUE for -bm, -bS, -bs below */
- if (*argrest == 'r')
- {
- list_queue_option = 8;
- argrest++;
- }
- else list_queue_option = 0;
-
- list_queue = TRUE;
-
- /* -bp: List the contents of the mail queue, top-level only */
-
- if (*argrest == 0) {}
-
- /* -bpu: List the contents of the mail queue, top-level undelivered */
-
- else if (Ustrcmp(argrest, "u") == 0) list_queue_option += 1;
-
- /* -bpa: List the contents of the mail queue, including all delivered */
-
- else if (Ustrcmp(argrest, "a") == 0) list_queue_option += 2;
-
- /* Unknown after -bp[r] */
-
- else
- {
- badarg = TRUE;
- break;
- }
- }
-
-
- /* -bP: List the configuration variables given as the address list.
- Force -v, so configuration errors get displayed. */
-
- else if (Ustrcmp(argrest, "P") == 0)
- {
- /* -bP config: we need to setup here, because later,
- * when list_options is checked, the config is read already */
- if (argv[i+1] && Ustrcmp(argv[i+1], "config") == 0)
- {
- list_config = TRUE;
- readconf_save_config(version_string);
- }
- else
- {
- list_options = TRUE;
- debug_selector |= D_v;
- debug_file = stderr;
- }
- }
-
- /* -brt: Test retry configuration lookup */
-
- else if (Ustrcmp(argrest, "rt") == 0)
- {
- checking = TRUE;
- test_retry_arg = i + 1;
- goto END_ARG;
- }
-
- /* -brw: Test rewrite configuration */
+ switch (*argrest++)
+ {
+ /* -bd: Run in daemon mode, awaiting SMTP connections.
+ -bdf: Ditto, but in the foreground.
+ */
+ case 'd':
+ f.daemon_listen = TRUE;
+ if (*argrest == 'f') f.background_daemon = FALSE;
+ else if (*argrest) badarg = TRUE;
+ break;
+
+ /* -be: Run in expansion test mode
+ -bem: Ditto, but read a message from a file first
+ */
+ case 'e':
+ expansion_test = checking = TRUE;
+ if (*argrest == 'm')
+ {
+ if (++i >= argc) { badarg = TRUE; break; }
+ expansion_test_message = argv[i];
+ argrest++;
+ }
+ if (*argrest) badarg = TRUE;
+ break;
+
+ /* -bF: Run system filter test */
+ case 'F':
+ filter_test |= checking = FTEST_SYSTEM;
+ if (*argrest) { badarg = TRUE; break; }
+ if (++i < argc) filter_test_sfile = argv[i]; else
+ exim_fail("exim: file name expected after %s\n", argv[i-1]);
+ break;
+
+ /* -bf: Run user filter test
+ -bfd: Set domain for filter testing
+ -bfl: Set local part for filter testing
+ -bfp: Set prefix for filter testing
+ -bfs: Set suffix for filter testing
+ */
+ case 'f':
+ if (!*argrest)
+ {
+ filter_test |= checking = FTEST_USER;
+ if (++i < argc) filter_test_ufile = argv[i];
+ else exim_fail("exim: file name expected after %s\n", argv[i-1]);
+ }
+ else
+ {
+ if (++i >= argc)
+ exim_fail("exim: string expected after %s\n", arg);
+ if (Ustrcmp(argrest, "d") == 0) ftest_domain = argv[i];
+ else if (Ustrcmp(argrest, "l") == 0) ftest_localpart = argv[i];
+ else if (Ustrcmp(argrest, "p") == 0) ftest_prefix = argv[i];
+ else if (Ustrcmp(argrest, "s") == 0) ftest_suffix = argv[i];
+ else badarg = TRUE;
+ }
+ break;
+
+ /* -bh: Host checking - an IP address must follow. */
+ case 'h':
+ if (!*argrest || Ustrcmp(argrest, "c") == 0)
+ {
+ if (++i >= argc) { badarg = TRUE; break; }
+ sender_host_address = argv[i];
+ host_checking = checking = f.log_testing_mode = TRUE;
+ f.host_checking_callout = *argrest == 'c';
+ message_logs = FALSE;
+ }
+ else badarg = TRUE;
+ break;
+
+ /* -bi: This option is used by sendmail to initialize *the* alias file,
+ though it has the -oA option to specify a different file. Exim has no
+ concept of *the* alias file, but since Sun's YP make script calls
+ sendmail this way, some support must be provided. */
+ case 'i':
+ if (!*++argrest) bi_option = TRUE;
+ else badarg = TRUE;
+ break;
+
+ /* -bI: provide information, of the type to follow after a colon.
+ This is an Exim flag. */
+ case 'I':
+ if (Ustrlen(argrest) >= 1 && *argrest == ':')
+ {
+ uschar *p = argrest+1;
+ 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;
+ }
+ else badarg = TRUE;
+ break;
+
+ /* -bm: Accept and deliver message - the default option. Reinstate
+ receiving_message, which got turned off for all -b options.
+ -bmalware: test the filename given for malware */
+ case 'm':
+ if (!*argrest) receiving_message = TRUE;
+ else if (Ustrcmp(argrest, "alware") == 0)
+ {
+ if (++i >= argc) { badarg = TRUE; break; }
+ checking = TRUE;
+ malware_test_file = argv[i];
+ }
+ else badarg = TRUE;
+ break;
+
+ /* -bnq: For locally originating messages, do not qualify unqualified
+ addresses. In the envelope, this causes errors; in header lines they
+ just get left. */
+ case 'n':
+ if (Ustrcmp(argrest, "q") == 0)
+ {
+ f.allow_unqualified_sender = FALSE;
+ f.allow_unqualified_recipient = FALSE;
+ }
+ else badarg = TRUE;
+ break;
+
+ /* -bpxx: List the contents of the mail queue, in various forms. If
+ the option is -bpc, just a queue count is needed. Otherwise, if the
+ first letter after p is r, then order is random. */
+ case 'p':
+ if (*argrest == 'c')
+ {
+ count_queue = TRUE;
+ if (*++argrest) badarg = TRUE;
+ break;
+ }
- else if (Ustrcmp(argrest, "rw") == 0)
- {
- checking = TRUE;
- test_rewrite_arg = i + 1;
- goto END_ARG;
- }
+ if (*argrest == 'r')
+ {
+ list_queue_option = 8;
+ argrest++;
+ }
+ else list_queue_option = 0;
- /* -bS: Read SMTP commands on standard input, but produce no replies -
- all errors are reported by sending messages. */
+ list_queue = TRUE;
- else if (Ustrcmp(argrest, "S") == 0)
- smtp_input = smtp_batched_input = receiving_message = TRUE;
+ /* -bp: List the contents of the mail queue, top-level only */
- /* -bs: Read SMTP commands on standard input and produce SMTP replies
- on standard output. */
+ if (!*argrest) {}
- else if (Ustrcmp(argrest, "s") == 0) smtp_input = receiving_message = TRUE;
+ /* -bpu: List the contents of the mail queue, top-level undelivered */
- /* -bt: address testing mode */
+ else if (Ustrcmp(argrest, "u") == 0) list_queue_option += 1;
- else if (Ustrcmp(argrest, "t") == 0)
- address_test_mode = checking = log_testing_mode = TRUE;
+ /* -bpa: List the contents of the mail queue, including all delivered */
- /* -bv: verify addresses */
+ else if (Ustrcmp(argrest, "a") == 0) list_queue_option += 2;
- else if (Ustrcmp(argrest, "v") == 0)
- verify_address_mode = checking = log_testing_mode = TRUE;
+ /* Unknown after -bp[r] */
- /* -bvs: verify sender addresses */
+ else badarg = TRUE;
+ break;
- else if (Ustrcmp(argrest, "vs") == 0)
- {
- verify_address_mode = checking = log_testing_mode = TRUE;
- verify_as_sender = TRUE;
- }
- /* -bV: Print version string and support details */
+ /* -bP: List the configuration variables given as the address list.
+ Force -v, so configuration errors get displayed. */
+ case 'P':
- else if (Ustrcmp(argrest, "V") == 0)
- {
- printf("Exim version %s #%s built %s\n", version_string,
- version_cnumber, version_date);
- printf("%s\n", CS version_copyright);
- version_printed = TRUE;
- show_whats_supported(stdout);
- log_testing_mode = TRUE;
- }
+ /* -bP config: we need to setup here, because later,
+ * when list_options is checked, the config is read already */
+ if (*argrest)
+ badarg = TRUE;
+ else if (argv[i+1] && Ustrcmp(argv[i+1], "config") == 0)
+ {
+ list_config = TRUE;
+ readconf_save_config(version_string);
+ }
+ else
+ {
+ list_options = TRUE;
+ debug_selector |= D_v;
+ debug_file = stderr;
+ }
+ break;
+
+ /* -brt: Test retry configuration lookup */
+ case 'r':
+ if (Ustrcmp(argrest, "t") == 0)
+ {
+ checking = TRUE;
+ test_retry_arg = i + 1;
+ goto END_ARG;
+ }
- /* -bw: inetd wait mode, accept a listening socket as stdin */
+ /* -brw: Test rewrite configuration */
- 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 if (Ustrcmp(argrest, "w") == 0)
+ {
+ checking = TRUE;
+ test_rewrite_arg = i + 1;
+ goto END_ARG;
+ }
+ else badarg = TRUE;
+ break;
+
+ /* -bS: Read SMTP commands on standard input, but produce no replies -
+ all errors are reported by sending messages. */
+ case 'S':
+ if (!*argrest)
+ smtp_input = smtp_batched_input = receiving_message = TRUE;
+ else badarg = TRUE;
+ break;
+
+ /* -bs: Read SMTP commands on standard input and produce SMTP replies
+ on standard output. */
+ case 's':
+ if (!*argrest) smtp_input = receiving_message = TRUE;
+ else badarg = TRUE;
+ break;
+
+ /* -bt: address testing mode */
+ case 't':
+ if (!*argrest)
+ f.address_test_mode = checking = f.log_testing_mode = TRUE;
+ else badarg = TRUE;
+ break;
+
+ /* -bv: verify addresses */
+ case 'v':
+ if (!*argrest)
+ verify_address_mode = checking = f.log_testing_mode = TRUE;
+
+ /* -bvs: verify sender addresses */
+
+ else if (Ustrcmp(argrest, "s") == 0)
+ {
+ verify_address_mode = checking = f.log_testing_mode = TRUE;
+ verify_as_sender = TRUE;
+ }
+ else badarg = TRUE;
+ break;
+
+ /* -bV: Print version string and support details */
+ case 'V':
+ if (!*argrest)
+ {
+ printf("Exim version %s #%s built %s\n", version_string,
+ version_cnumber, version_date);
+ printf("%s\n", CS version_copyright);
+ version_printed = TRUE;
+ show_whats_supported(stdout);
+ f.log_testing_mode = TRUE;
+ }
+ else badarg = TRUE;
+ break;
+
+ /* -bw: inetd wait mode, accept a listening socket as stdin */
+ case 'w':
+ f.inetd_wait_mode = TRUE;
+ f.background_daemon = FALSE;
+ f.daemon_listen = TRUE;
+ if (*argrest)
+ if ((inetd_wait_timeout = readconf_readtime(argrest, 0, FALSE)) <= 0)
+ exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
+ break;
+
+ default:
+ badarg = TRUE;
+ break;
+ }
+ break;
}
- else badarg = TRUE;
- break;
-
/* -C: change configuration file list; ignore if it isn't really
a change! Enforce a prefix check if required. */
Ustrncmp(filename, ALT_CONFIG_PREFIX, len) != 0 ||
Ustrstr(filename, "/../") != NULL) &&
(Ustrcmp(filename, "/dev/null") != 0 || real_uid != root_uid))
- {
- fprintf(stderr, "-C Permission denied\n");
- exit(EXIT_FAILURE);
- }
+ exim_fail("-C Permission denied\n");
}
#endif
if (real_uid != root_uid)
&& real_uid != config_uid
#endif
)
- trusted_config = FALSE;
+ f.trusted_config = FALSE;
else
{
FILE *trust_list = Ufopen(TRUSTED_CONFIG_LIST, "rb");
) || /* or */
(statbuf.st_mode & 2) != 0) /* world writeable */
{
- trusted_config = FALSE;
+ f.trusted_config = FALSE;
fclose(trust_list);
}
else
{
/* Well, the trust list at least is up to scratch... */
- void *reset_point = store_get(0);
+ rmark reset_point = store_mark();
uschar *trusted_configs[32];
int nr_configs = 0;
int i = 0;
int sep = 0;
const uschar *list = argrest;
uschar *filename;
- while (trusted_config && (filename = string_nextinlist(&list,
+ while (f.trusted_config && (filename = string_nextinlist(&list,
&sep, big_buffer, big_buffer_size)) != NULL)
{
for (i=0; i < nr_configs; i++)
- {
if (Ustrcmp(filename, trusted_configs[i]) == 0)
break;
- }
if (i == nr_configs)
{
- trusted_config = FALSE;
+ f.trusted_config = FALSE;
break;
}
}
- store_reset(reset_point);
- }
- else
- {
- /* No valid prefixes found in trust_list file. */
- trusted_config = FALSE;
}
+ else /* No valid prefixes found in trust_list file. */
+ f.trusted_config = FALSE;
+ store_reset(reset_point);
}
}
- else
- {
- /* Could not open trust_list file. */
- trusted_config = FALSE;
- }
+ else /* Could not open trust_list file. */
+ f.trusted_config = FALSE;
}
#else
/* Not root; don't trust config */
- trusted_config = FALSE;
+ f.trusted_config = FALSE;
#endif
}
config_main_filelist = argrest;
- config_changed = TRUE;
+ f.config_changed = TRUE;
}
break;
/* -D: set up a macro definition */
case 'D':
- #ifdef DISABLE_D_OPTION
- fprintf(stderr, "exim: -D is not available in this Exim binary\n");
- exit(EXIT_FAILURE);
- #else
+#ifdef DISABLE_D_OPTION
+ exim_fail("exim: -D is not available in this Exim binary\n");
+#else
{
int ptr = 0;
macro_item *m;
while (isspace(*s)) s++;
if (*s < 'A' || *s > 'Z')
- {
- fprintf(stderr, "exim: macro name set by -D must start with "
+ exim_fail("exim: macro name set by -D must start with "
"an upper case letter\n");
- exit(EXIT_FAILURE);
- }
while (isalnum(*s) || *s == '_')
{
for (m = macros_user; m; m = m->next)
if (Ustrcmp(m->name, name) == 0)
- {
- fprintf(stderr, "exim: duplicated -D in command line\n");
- exit(EXIT_FAILURE);
- }
+ exim_fail("exim: duplicated -D in command line\n");
m = macro_create(name, s, TRUE);
if (clmacro_count >= MAX_CLMACROS)
- {
- fprintf(stderr, "exim: too many -D options on command line\n");
- exit(EXIT_FAILURE);
- }
- clmacros[clmacro_count++] = string_sprintf("-D%s=%s", m->name,
- m->replacement);
+ exim_fail("exim: too many -D options on command line\n");
+ clmacros[clmacro_count++] =
+ string_sprintf("-D%s=%s", m->name, m->replacement);
}
#endif
break;
debug_file = NULL;
if (*argrest == 'd')
{
- debug_daemon = TRUE;
+ f.debug_daemon = TRUE;
argrest++;
}
if (*argrest != 0)
message_reference at it, for logging. */
case 'E':
- local_error_message = TRUE;
+ f.local_error_message = TRUE;
if (mac_ismsgid(argrest)) message_reference = argrest;
break;
{ badarg = TRUE; break; }
}
originator_name = argrest;
- sender_name_forced = TRUE;
+ f.sender_name_forced = TRUE;
break;
{ badarg = TRUE; break; }
}
if (*argrest == 0)
- sender_address = string_sprintf(""); /* Ensure writeable memory */
+ *(sender_address = store_get(1, FALSE)) = '\0'; /* Ensure writeable memory */
else
{
uschar *temp = argrest + Ustrlen(argrest) - 1;
#endif
sender_address = parse_extract_address(argrest, &errmess,
&dummy_start, &dummy_end, &sender_address_domain, TRUE);
+ sender_address = string_copy_taint(sender_address, TRUE);
#ifdef SUPPORT_I18N
message_smtputf8 = string_is_utf8(sender_address);
allow_utf8_domains = FALSE;
#endif
allow_domain_literals = FALSE;
strip_trailing_dot = FALSE;
- if (sender_address == NULL)
- {
- fprintf(stderr, "exim: bad -f address \"%s\": %s\n", argrest, errmess);
- return EXIT_FAILURE;
- }
+ if (!sender_address)
+ exim_fail("exim: bad -f address \"%s\": %s\n", argrest, errmess);
}
- sender_address_forced = TRUE;
+ f.sender_address_forced = TRUE;
}
break;
not to be documented for sendmail but mailx (at least) uses it) */
case 'i':
- if (*argrest == 0) dot_ends = FALSE; else badarg = TRUE;
+ if (*argrest == 0) f.dot_ends = FALSE; else badarg = TRUE;
break;
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 = Ustrlen(argrest)) > 32)
+ exim_fail("exim: the -L syslog name is too long: \"%s\"\n", argrest);
if (sz < 1)
- {
- fprintf(stderr, "exim: the -L syslog name is too short\n");
- return EXIT_FAILURE;
- }
+ exim_fail("exim: the -L syslog name is too short\n");
cmdline_syslog_name = argrest;
break;
EXIM_SOCKLEN_T size = sizeof(interface_sock);
if (argc != i + 6)
- {
- fprintf(stderr, "exim: too many or too few arguments after -MC\n");
- return EXIT_FAILURE;
- }
+ exim_fail("exim: too many or too few arguments after -MC\n");
if (msg_action_arg >= 0)
- {
- fprintf(stderr, "exim: incompatible arguments\n");
- return EXIT_FAILURE;
- }
+ exim_fail("exim: incompatible arguments\n");
continue_transport = argv[++i];
continue_hostname = argv[++i];
queue_run_pipe = passed_qr_pipe;
if (!mac_ismsgid(argv[i]))
- {
- fprintf(stderr, "exim: malformed message id %s after -MC option\n",
+ exim_fail("exim: malformed message id %s after -MC option\n",
argv[i]);
- return EXIT_FAILURE;
- }
/* Set up $sending_ip_address and $sending_port, unless proxied */
sending_ip_address = host_ntoa(-1, &interface_sock, NULL,
&sending_port);
else
- {
- fprintf(stderr, "exim: getsockname() failed after -MC option: %s\n",
+ exim_fail("exim: getsockname() failed after -MC option: %s\n",
strerror(errno));
- return EXIT_FAILURE;
- }
- if (running_in_test_harness) millisleep(500);
+ testharness_pause_ms(500);
break;
}
precedes -MC (see above). The flag indicates that the host to which
Exim is connected has accepted an AUTH sequence. */
- case 'A': smtp_authenticated = TRUE; break;
+ case 'A': f.smtp_authenticated = TRUE; break;
/* -MCD: set the smtp_use_dsn flag; this indicates that the host
that exim is connected to supports the esmtp extension DSN */
case 'S': smtp_peer_options |= OPTION_SIZE; break;
-#ifdef SUPPORT_TLS
+#ifndef DISABLE_TLS
/* -MCt: similar to -MCT below but the connection is still open
- via a proxy proces which handles the TLS context and coding.
+ via a proxy process which handles the TLS context and coding.
Require three arguments for the proxied local address and port,
and the TLS cipher. */
default: badarg = TRUE; break;
}
- break;
+ break;
}
/* -M[x]: various operations on the following list of message ids:
else if (*argrest == 0)
{
msg_action = MSG_DELIVER;
- forced_delivery = deliver_force_thaw = TRUE;
+ forced_delivery = f.deliver_force_thaw = TRUE;
}
else if (Ustrcmp(argrest, "ar") == 0)
{
msg_action = MSG_DELIVER;
deliver_give_up = TRUE;
}
+ else if (Ustrcmp(argrest, "G") == 0)
+ {
+ msg_action = MSG_SETQUEUE;
+ queue_name_dest = argv[++i];
+ }
else if (Ustrcmp(argrest, "mad") == 0)
{
msg_action = MSG_MARK_ALL_DELIVERED;
msg_action_arg = i + 1;
if (msg_action_arg >= argc)
- {
- fprintf(stderr, "exim: no message ids given after %s option\n", arg);
- return EXIT_FAILURE;
- }
+ exim_fail("exim: no message ids given after %s option\n", arg);
/* Some require only message ids to follow */
if (!one_msg_action)
{
- int j;
- for (j = msg_action_arg; j < argc; j++) if (!mac_ismsgid(argv[j]))
- {
- fprintf(stderr, "exim: malformed message id %s after %s option\n",
+ for (int j = msg_action_arg; j < argc; j++) if (!mac_ismsgid(argv[j]))
+ exim_fail("exim: malformed message id %s after %s option\n",
argv[j], arg);
- return EXIT_FAILURE;
- }
goto END_ARG; /* Remaining args are ids */
}
else
{
if (!mac_ismsgid(argv[msg_action_arg]))
- {
- fprintf(stderr, "exim: malformed message id %s after %s option\n",
+ exim_fail("exim: malformed message id %s after %s option\n",
argv[msg_action_arg], arg);
- return EXIT_FAILURE;
- }
i++;
}
break;
case 'N':
if (*argrest == 0)
{
- dont_deliver = TRUE;
+ f.dont_deliver = TRUE;
debug_selector |= D_v;
debug_file = stderr;
}
case 'O':
if (*argrest == 0)
- {
if (++i >= argc)
- {
- fprintf(stderr, "exim: string expected after -O\n");
- exit(EXIT_FAILURE);
- }
- }
+ exim_fail("exim: string expected after -O\n");
break;
case 'o':
-
- /* -oA: Set an argument for the bi command (sendmail's "alternate alias
- file" option). */
-
- if (*argrest == 'A')
+ switch (*argrest++)
{
- alias_arg = argrest + 1;
- if (alias_arg[0] == 0)
- {
- if (i+1 < argc) alias_arg = argv[++i]; else
- {
- fprintf(stderr, "exim: string expected after -oA\n");
- exit(EXIT_FAILURE);
- }
- }
- }
+ /* -oA: Set an argument for the bi command (sendmail's "alternate alias
+ file" option). */
+ case 'A':
+ if (!*(alias_arg = argrest))
+ if (i+1 < argc) alias_arg = argv[++i];
+ else exim_fail("exim: string expected after -oA\n");
+ break;
- /* -oB: Set a connection message max value for remote deliveries */
+ /* -oB: Set a connection message max value for remote deliveries */
+ case 'B':
+ {
+ uschar * p = argrest;
+ if (!*p)
+ if (i+1 < argc && isdigit((argv[i+1][0])))
+ p = argv[++i];
+ else
+ {
+ connection_max_messages = 1;
+ p = NULL;
+ }
- else if (*argrest == 'B')
- {
- uschar *p = argrest + 1;
- if (p[0] == 0)
- {
- if (i+1 < argc && isdigit((argv[i+1][0]))) p = argv[++i]; else
- {
- connection_max_messages = 1;
- p = NULL;
- }
- }
+ if (p)
+ {
+ if (!isdigit(*p))
+ exim_fail("exim: number expected after -oB\n");
+ connection_max_messages = Uatoi(p);
+ }
+ }
+ break;
- if (p != NULL)
- {
- if (!isdigit(*p))
- {
- fprintf(stderr, "exim: number expected after -oB\n");
- exit(EXIT_FAILURE);
- }
- connection_max_messages = Uatoi(p);
- }
- }
+ /* -odb: background delivery */
- /* -odb: background delivery */
+ case 'd':
+ if (Ustrcmp(argrest, "b") == 0)
+ {
+ f.synchronous_delivery = FALSE;
+ arg_queue_only = FALSE;
+ queue_only_set = TRUE;
+ }
- else if (Ustrcmp(argrest, "db") == 0)
- {
- synchronous_delivery = FALSE;
- arg_queue_only = FALSE;
- queue_only_set = TRUE;
- }
+ /* -odd: testsuite-only: add no inter-process delays */
- /* -odf: foreground delivery (smail-compatible option); same effect as
- -odi: interactive (synchronous) delivery (sendmail-compatible option)
- */
+ else if (Ustrcmp(argrest, "d") == 0)
+ f.testsuite_delays = FALSE;
- else if (Ustrcmp(argrest, "df") == 0 || Ustrcmp(argrest, "di") == 0)
- {
- synchronous_delivery = TRUE;
- arg_queue_only = FALSE;
- queue_only_set = TRUE;
- }
+ /* -odf: foreground delivery (smail-compatible option); same effect as
+ -odi: interactive (synchronous) delivery (sendmail-compatible option)
+ */
- /* -odq: queue only */
+ else if (Ustrcmp(argrest, "f") == 0 || Ustrcmp(argrest, "i") == 0)
+ {
+ f.synchronous_delivery = TRUE;
+ arg_queue_only = FALSE;
+ queue_only_set = TRUE;
+ }
- else if (Ustrcmp(argrest, "dq") == 0)
- {
- synchronous_delivery = FALSE;
- arg_queue_only = TRUE;
- queue_only_set = TRUE;
- }
+ /* -odq: queue only */
- /* -odqs: queue SMTP only - do local deliveries and remote routing,
- but no remote delivery */
+ else if (Ustrcmp(argrest, "q") == 0)
+ {
+ f.synchronous_delivery = FALSE;
+ arg_queue_only = TRUE;
+ queue_only_set = TRUE;
+ }
- else if (Ustrcmp(argrest, "dqs") == 0)
- {
- queue_smtp = TRUE;
- arg_queue_only = FALSE;
- queue_only_set = TRUE;
- }
+ /* -odqs: queue SMTP only - do local deliveries and remote routing,
+ but no remote delivery */
+
+ else if (Ustrcmp(argrest, "qs") == 0)
+ {
+ f.queue_smtp = TRUE;
+ arg_queue_only = FALSE;
+ queue_only_set = TRUE;
+ }
+ else badarg = TRUE;
+ break;
- /* -oex: Sendmail error flags. As these are also accepted without the
- leading -o prefix, for compatibility with vacation and other callers,
- they are handled with -e above. */
+ /* -oex: Sendmail error flags. As these are also accepted without the
+ leading -o prefix, for compatibility with vacation and other callers,
+ they are handled with -e above. */
- /* -oi: Set flag so dot doesn't end non-SMTP input (same as -i)
- -oitrue: Another sendmail syntax for the same */
+ /* -oi: Set flag so dot doesn't end non-SMTP input (same as -i)
+ -oitrue: Another sendmail syntax for the same */
- else if (Ustrcmp(argrest, "i") == 0 ||
- Ustrcmp(argrest, "itrue") == 0)
- dot_ends = FALSE;
+ case 'i':
+ if (!*argrest || Ustrcmp(argrest, "true") == 0)
+ f.dot_ends = FALSE;
+ else badarg = TRUE;
+ break;
/* -oM*: Set various characteristics for an incoming message; actually
acted on for trusted callers only. */
- else if (*argrest == 'M')
- {
- if (i+1 >= argc)
- {
- fprintf(stderr, "exim: data expected after -o%s\n", argrest);
- exit(EXIT_FAILURE);
- }
-
- /* -oMa: Set sender host address */
+ case 'M':
+ {
+ if (i+1 >= argc)
+ exim_fail("exim: data expected after -oM%s\n", argrest);
- if (Ustrcmp(argrest, "Ma") == 0) sender_host_address = argv[++i];
+ /* -oMa: Set sender host address */
- /* -oMaa: Set authenticator name */
+ if (Ustrcmp(argrest, "a") == 0) sender_host_address = argv[++i];
- else if (Ustrcmp(argrest, "Maa") == 0)
- sender_host_authenticated = argv[++i];
+ /* -oMaa: Set authenticator name */
- /* -oMas: setting authenticated sender */
+ else if (Ustrcmp(argrest, "aa") == 0)
+ sender_host_authenticated = argv[++i];
- else if (Ustrcmp(argrest, "Mas") == 0) authenticated_sender = argv[++i];
+ /* -oMas: setting authenticated sender */
- /* -oMai: setting authenticated id */
+ else if (Ustrcmp(argrest, "as") == 0)
+ authenticated_sender = string_copy_taint(argv[++i], TRUE);
- else if (Ustrcmp(argrest, "Mai") == 0) authenticated_id = argv[++i];
+ /* -oMai: setting authenticated id */
- /* -oMi: Set incoming interface address */
+ else if (Ustrcmp(argrest, "ai") == 0)
+ authenticated_id = string_copy_taint(argv[++i], TRUE);
- else if (Ustrcmp(argrest, "Mi") == 0) interface_address = argv[++i];
+ /* -oMi: Set incoming interface address */
- /* -oMm: Message reference */
+ else if (Ustrcmp(argrest, "i") == 0) interface_address = argv[++i];
- else if (Ustrcmp(argrest, "Mm") == 0)
- {
- if (!mac_ismsgid(argv[i+1]))
- {
- fprintf(stderr,"-oMm must be a valid message ID\n");
- exit(EXIT_FAILURE);
- }
- if (!trusted_config)
- {
- fprintf(stderr,"-oMm must be called by a trusted user/config\n");
- exit(EXIT_FAILURE);
- }
- message_reference = argv[++i];
- }
+ /* -oMm: Message reference */
- /* -oMr: Received protocol */
+ else if (Ustrcmp(argrest, "m") == 0)
+ {
+ if (!mac_ismsgid(argv[i+1]))
+ exim_fail("-oMm must be a valid message ID\n");
+ if (!f.trusted_config)
+ exim_fail("-oMm must be called by a trusted user/config\n");
+ message_reference = argv[++i];
+ }
- else if (Ustrcmp(argrest, "Mr") == 0)
+ /* -oMr: Received protocol */
- if (received_protocol)
- {
- fprintf(stderr, "received_protocol is set already\n");
- exit(EXIT_FAILURE);
- }
- else received_protocol = argv[++i];
+ else if (Ustrcmp(argrest, "r") == 0)
- /* -oMs: Set sender host name */
+ if (received_protocol)
+ exim_fail("received_protocol is set already\n");
+ else
+ received_protocol = argv[++i];
- else if (Ustrcmp(argrest, "Ms") == 0) sender_host_name = argv[++i];
+ /* -oMs: Set sender host name */
- /* -oMt: Set sender ident */
+ else if (Ustrcmp(argrest, "s") == 0)
+ sender_host_name = string_copy_taint(argv[++i], TRUE);
- else if (Ustrcmp(argrest, "Mt") == 0)
- {
- sender_ident_set = TRUE;
- sender_ident = argv[++i];
- }
+ /* -oMt: Set sender ident */
- /* Else a bad argument */
+ else if (Ustrcmp(argrest, "t") == 0)
+ {
+ sender_ident_set = TRUE;
+ sender_ident = argv[++i];
+ }
- else
- {
- badarg = TRUE;
- break;
- }
- }
+ /* Else a bad argument */
- /* -om: Me-too flag for aliases. Exim always does this. Some programs
- seem to call this as -m (undocumented), so that is also accepted (see
- above). */
+ else
+ badarg = TRUE;
+ }
+ break;
- else if (Ustrcmp(argrest, "m") == 0) {}
+ /* -om: Me-too flag for aliases. Exim always does this. Some programs
+ seem to call this as -m (undocumented), so that is also accepted (see
+ above). */
+ /* -oo: An ancient flag for old-style addresses which still seems to
+ crop up in some calls (see in SCO). */
- /* -oo: An ancient flag for old-style addresses which still seems to
- crop up in some calls (see in SCO). */
+ case 'm':
+ case 'o':
+ if (*argrest) badarg = TRUE;
+ break;
- else if (Ustrcmp(argrest, "o") == 0) {}
+ /* -oP <name>: set pid file path for daemon
+ -oPX: delete pid file of daemon */
- /* -oP <name>: set pid file path for daemon */
+ case 'P':
+ if (!*argrest) override_pid_file_path = argv[++i];
+ else if (Ustrcmp(argrest, "X") == 0) delete_pid_file();
+ else badarg = TRUE;
+ break;
- else if (Ustrcmp(argrest, "P") == 0)
- override_pid_file_path = argv[++i];
- /* -or <n>: set timeout for non-SMTP acceptance
- -os <n>: set timeout for SMTP acceptance */
+ /* -or <n>: set timeout for non-SMTP acceptance
+ -os <n>: set timeout for SMTP acceptance */
- else if (*argrest == 'r' || *argrest == 's')
- {
- int *tp = (*argrest == 'r')?
- &arg_receive_timeout : &arg_smtp_receive_timeout;
- if (argrest[1] == 0)
- {
- if (i+1 < argc) *tp= readconf_readtime(argv[++i], 0, FALSE);
- }
- else *tp = readconf_readtime(argrest + 1, 0, FALSE);
- if (*tp < 0)
- {
- fprintf(stderr, "exim: bad time value %s: abandoned\n", argv[i]);
- exit(EXIT_FAILURE);
- }
- }
+ case 'r':
+ case 's':
+ {
+ int * tp = argrest[-1] == 'r'
+ ? &arg_receive_timeout : &arg_smtp_receive_timeout;
+ if (*argrest)
+ *tp = readconf_readtime(argrest, 0, FALSE);
+ else if (i+1 < argc)
+ *tp = readconf_readtime(argv[++i], 0, FALSE);
+
+ if (*tp < 0)
+ exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
+ }
+ break;
- /* -oX <list>: Override local_interfaces and/or default daemon ports */
+ /* -oX <list>: Override local_interfaces and/or default daemon ports */
- else if (Ustrcmp(argrest, "X") == 0)
- override_local_interfaces = argv[++i];
+ case 'X':
+ if (*argrest) badarg = TRUE;
+ else override_local_interfaces = argv[++i];
+ break;
- /* Unknown -o argument */
+ /* Unknown -o argument */
- else badarg = TRUE;
+ default:
+ badarg = TRUE;
+ }
break;
uschar *hn;
if (received_protocol)
- {
- fprintf(stderr, "received_protocol is set already\n");
- exit(EXIT_FAILURE);
- }
+ exim_fail("received_protocol is set already\n");
hn = Ustrchr(argrest, ':');
if (hn == NULL)
case 'q':
receiving_message = FALSE;
if (queue_interval >= 0)
- {
- fprintf(stderr, "exim: -q specified more than once\n");
- exit(EXIT_FAILURE);
- }
+ exim_fail("exim: -q specified more than once\n");
/* -qq...: Do queue runs in a 2-stage manner */
if (*argrest == 'q')
{
- queue_2stage = TRUE;
+ f.queue_2stage = TRUE;
argrest++;
}
if (*argrest == 'i')
{
- queue_run_first_delivery = TRUE;
+ f.queue_run_first_delivery = TRUE;
argrest++;
}
if (*argrest == 'f')
{
- queue_run_force = TRUE;
+ f.queue_run_force = TRUE;
if (*++argrest == 'f')
{
- deliver_force_thaw = TRUE;
+ f.deliver_force_thaw = TRUE;
argrest++;
}
}
if (*argrest == 'l')
{
- queue_run_local = TRUE;
+ f.queue_run_local = TRUE;
argrest++;
}
/* -q[f][f][l][G<name>]: Run the queue, optionally forced, optionally local
only, optionally named, optionally starting from a given message id. */
- if (*argrest == 0 &&
- (i + 1 >= argc || argv[i+1][0] == '-' || mac_ismsgid(argv[i+1])))
- {
- queue_interval = 0;
- if (i+1 < argc && mac_ismsgid(argv[i+1]))
- start_queue_run_id = argv[++i];
- if (i+1 < argc && mac_ismsgid(argv[i+1]))
- stop_queue_run_id = argv[++i];
- }
+ if (!(list_queue || count_queue))
+ if (*argrest == 0
+ && (i + 1 >= argc || argv[i+1][0] == '-' || mac_ismsgid(argv[i+1])))
+ {
+ queue_interval = 0;
+ if (i+1 < argc && mac_ismsgid(argv[i+1]))
+ start_queue_run_id = argv[++i];
+ if (i+1 < argc && mac_ismsgid(argv[i+1]))
+ stop_queue_run_id = argv[++i];
+ }
/* -q[f][f][l][G<name>/]<n>: Run the queue at regular intervals, optionally
forced, optionally local only, optionally named. */
- else if ((queue_interval = readconf_readtime(*argrest ? argrest : argv[++i],
- 0, FALSE)) <= 0)
- {
- fprintf(stderr, "exim: bad time value %s: abandoned\n", argv[i]);
- exit(EXIT_FAILURE);
- }
+ else if ((queue_interval = readconf_readtime(*argrest ? argrest : argv[++i],
+ 0, FALSE)) <= 0)
+ exim_fail("exim: bad time value %s: abandoned\n", argv[i]);
break;
argument. */
if (*argrest != 0)
- {
- int i;
- for (i = 0; i < nelem(rsopts); i++)
+ for (int i = 0; i < nelem(rsopts); i++)
if (Ustrcmp(argrest, rsopts[i]) == 0)
{
- if (i != 2) queue_run_force = TRUE;
- if (i >= 2) deliver_selectstring_regex = TRUE;
- if (i == 1 || i == 4) deliver_force_thaw = TRUE;
+ if (i != 2) f.queue_run_force = TRUE;
+ if (i >= 2) f.deliver_selectstring_regex = TRUE;
+ if (i == 1 || i == 4) f.deliver_force_thaw = TRUE;
argrest += Ustrlen(rsopts[i]);
}
- }
/* -R: Set string to match in addresses for forced queue run to
pick out particular messages. */
else if (i+1 < argc)
deliver_selectstring = argv[++i];
else
- {
- fprintf(stderr, "exim: string expected after -R\n");
- exit(EXIT_FAILURE);
- }
+ exim_fail("exim: string expected after -R\n");
break;
argument. */
if (*argrest)
- {
- int i;
- for (i = 0; i < nelem(rsopts); i++)
+ for (int i = 0; i < nelem(rsopts); i++)
if (Ustrcmp(argrest, rsopts[i]) == 0)
{
- if (i != 2) queue_run_force = TRUE;
- if (i >= 2) deliver_selectstring_sender_regex = TRUE;
- if (i == 1 || i == 4) deliver_force_thaw = TRUE;
+ if (i != 2) f.queue_run_force = TRUE;
+ if (i >= 2) f.deliver_selectstring_sender_regex = TRUE;
+ if (i == 1 || i == 4) f.deliver_force_thaw = TRUE;
argrest += Ustrlen(rsopts[i]);
}
- }
/* -S: Set string to match in addresses for forced queue run to
pick out particular messages. */
else if (i+1 < argc)
deliver_selectstring_sender = argv[++i];
else
- {
- fprintf(stderr, "exim: string expected after -S\n");
- exit(EXIT_FAILURE);
- }
+ exim_fail("exim: string expected after -S\n");
break;
/* -Tqt is an option that is exclusively for use by the testing suite.
tested. Otherwise variability of clock ticks etc. cause problems. */
case 'T':
- if (running_in_test_harness && Ustrcmp(argrest, "qt") == 0)
+ if (f.running_in_test_harness && Ustrcmp(argrest, "qt") == 0)
fudged_queue_times = argv[++i];
else badarg = TRUE;
break;
else if (Ustrcmp(argrest, "i") == 0)
{
extract_recipients = TRUE;
- dot_ends = FALSE;
+ f.dot_ends = FALSE;
}
/* -tls-on-connect: don't wait for STARTTLS (for old clients) */
- #ifdef SUPPORT_TLS
+ #ifndef DISABLE_TLS
else if (Ustrcmp(argrest, "ls-on-connect") == 0) tls_in.on_connect = TRUE;
#endif
case 'X':
if (*argrest == '\0')
if (++i >= argc)
- {
- fprintf(stderr, "exim: string expected after -X\n");
- exit(EXIT_FAILURE);
- }
+ exim_fail("exim: string expected after -X\n");
break;
case 'z':
if (*argrest == '\0')
- if (++i < argc) log_oneline = argv[i]; else
- {
- fprintf(stderr, "exim: file name expected after %s\n", argv[i-1]);
- exit(EXIT_FAILURE);
- }
+ if (++i < argc)
+ log_oneline = argv[i];
+ else
+ exim_fail("exim: file name expected after %s\n", argv[i-1]);
break;
/* All other initial characters are errors */
/* Failed to recognize the option, or syntax error */
if (badarg)
- {
- fprintf(stderr, "exim abandoned: unknown, malformed, or incomplete "
+ exim_fail("exim abandoned: unknown, malformed, or incomplete "
"option %s\n", arg);
- exit(EXIT_FAILURE);
- }
}
/* Arguments have been processed. Check for incompatibilities. */
if ((
(smtp_input || extract_recipients || recipients_arg < argc) &&
- (daemon_listen || queue_interval >= 0 || bi_option ||
+ (f.daemon_listen || queue_interval >= 0 || bi_option ||
test_retry_arg >= 0 || test_rewrite_arg >= 0 ||
filter_test != FTEST_NONE || (msg_action_arg > 0 && !one_msg_action))
) ||
(
msg_action_arg > 0 &&
- (daemon_listen || queue_interval > 0 || list_options ||
+ (f.daemon_listen || queue_interval > 0 || list_options ||
(checking && msg_action != MSG_LOAD) ||
bi_option || test_retry_arg >= 0 || test_rewrite_arg >= 0)
) ||
(
- (daemon_listen || queue_interval > 0) &&
+ (f.daemon_listen || queue_interval > 0) &&
(sender_address != NULL || list_options || list_queue || checking ||
bi_option)
) ||
(
- daemon_listen && queue_interval == 0
+ f.daemon_listen && queue_interval == 0
) ||
(
- inetd_wait_mode && queue_interval >= 0
+ f.inetd_wait_mode && queue_interval >= 0
) ||
(
list_options &&
) ||
(
verify_address_mode &&
- (address_test_mode || smtp_input || extract_recipients ||
+ (f.address_test_mode || smtp_input || extract_recipients ||
filter_test != FTEST_NONE || bi_option)
) ||
(
- address_test_mode && (smtp_input || extract_recipients ||
+ f.address_test_mode && (smtp_input || extract_recipients ||
filter_test != FTEST_NONE || bi_option)
) ||
(
(!expansion_test || expansion_test_message != NULL)
)
)
- {
- fprintf(stderr, "exim: incompatible command-line options or arguments\n");
- exit(EXIT_FAILURE);
- }
+ exim_fail("exim: incompatible command-line options or arguments\n");
/* If debugging is set up, set the file and the file descriptor to pass on to
child processes. It should, of course, be 2 for stderr. Also, force the daemon
{
debug_file = stderr;
debug_fd = fileno(debug_file);
- background_daemon = FALSE;
- if (running_in_test_harness) millisleep(100); /* lets caller finish */
+ f.background_daemon = FALSE;
+ testharness_pause_ms(100); /* lets caller finish */
if (debug_selector != D_v) /* -v only doesn't show this */
{
debug_printf("Exim version %s uid=%ld gid=%ld pid=%d D=%x\n",
till after reading the config, which might specify the exim gid. Therefore,
save the group list here first. */
-group_count = getgroups(NGROUPS_MAX, group_list);
-if (group_count < 0)
- {
- fprintf(stderr, "exim: getgroups() failed: %s\n", strerror(errno));
- exit(EXIT_FAILURE);
- }
+if ((group_count = getgroups(nelem(group_list), group_list)) < 0)
+ exim_fail("exim: getgroups() failed: %s\n", strerror(errno));
/* There is a fundamental difference in some BSD systems in the matter of
groups. FreeBSD and BSDI are known to be different; NetBSD and OpenBSD are
list. Calling setgroups() with zero groups on a "different" system results in
an error return. The following code should cope with both types of system.
+ Unfortunately, recent MacOS, which should be a FreeBSD, "helpfully" succeeds
+ the "setgroups() with zero groups" - and changes the egid.
+ Thanks to that we had to stash the original_egid above, for use below
+ in the call to exim_setugid().
+
However, if this process isn't running as root, setgroups() can't be used
-since you have to be root to run it, even if throwing away groups. Not being
-root here happens only in some unusual configurations. We just ignore the
-error. */
+since you have to be root to run it, even if throwing away groups.
+Except, sigh, for Hurd - where you can.
+Not being root here happens only in some unusual configurations. */
-if (setgroups(0, NULL) != 0)
- {
- if (setgroups(1, group_list) != 0 && !unprivileged)
- {
- fprintf(stderr, "exim: setgroups() failed: %s\n", strerror(errno));
- exit(EXIT_FAILURE);
- }
- }
+if ( !unprivileged
+#ifndef OS_SETGROUPS_ZERO_DROPS_ALL
+ && setgroups(0, NULL) != 0
+#endif
+ && setgroups(1, group_list) != 0)
+ exim_fail("exim: setgroups() failed: %s\n", strerror(errno));
/* If the configuration file name has been altered by an argument on the
command line (either a new file name or a macro definition) and the caller is
configuration file changes and macro definitions haven't happened. */
if (( /* EITHER */
- (!trusted_config || /* Config changed, or */
+ (!f.trusted_config || /* Config changed, or */
!macros_trusted(opt_D_used)) && /* impermissible macros and */
real_uid != root_uid && /* Not root, and */
- !running_in_test_harness /* Not fudged */
+ !f.running_in_test_harness /* Not fudged */
) || /* OR */
expansion_test /* expansion testing */
|| /* OR */
Note that if the invoker is Exim, the logs remain available. Messing with
this causes unlogged successful deliveries. */
- if ((log_stderr != NULL) && (real_uid != exim_uid))
- really_exim = FALSE;
+ if (log_stderr && real_uid != exim_uid)
+ f.really_exim = FALSE;
}
/* Privilege is to be retained for the moment. It may be dropped later,
the real uid to the effective so that subsequent re-execs of Exim are done by a
privileged user. */
-else exim_setugid(geteuid(), getegid(), FALSE, US"forcing real = effective");
+else
+ exim_setugid(geteuid(), original_egid, FALSE, US"forcing real = effective");
/* If testing a filter, open the file(s) now, before wasting time doing other
setups and reading the message. */
-if ((filter_test & FTEST_SYSTEM) != 0)
- {
- filter_sfd = Uopen(filter_test_sfile, O_RDONLY, 0);
- if (filter_sfd < 0)
- {
- fprintf(stderr, "exim: failed to open %s: %s\n", filter_test_sfile,
+if (filter_test & FTEST_SYSTEM)
+ if ((filter_sfd = Uopen(filter_test_sfile, O_RDONLY, 0)) < 0)
+ exim_fail("exim: failed to open %s: %s\n", filter_test_sfile,
strerror(errno));
- return EXIT_FAILURE;
- }
- }
-if ((filter_test & FTEST_USER) != 0)
- {
- filter_ufd = Uopen(filter_test_ufile, O_RDONLY, 0);
- if (filter_ufd < 0)
- {
- fprintf(stderr, "exim: failed to open %s: %s\n", filter_test_ufile,
+if (filter_test & FTEST_USER)
+ if ((filter_ufd = Uopen(filter_test_ufile, O_RDONLY, 0)) < 0)
+ exim_fail("exim: failed to open %s: %s\n", filter_test_ufile,
strerror(errno));
- return EXIT_FAILURE;
- }
- }
/* Initialise lookup_list
If debugging, already called above via version reporting.
init_lookup_list();
#ifdef SUPPORT_I18N
-if (running_in_test_harness) smtputf8_advertise_hosts = NULL;
+if (f.running_in_test_harness) smtputf8_advertise_hosts = NULL;
#endif
/* 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.
-NOTE: immediatly after opening the configuration file we change the working
+NOTE: immediately after opening the configuration file we change the working
directory to "/"! Later we change to $spool_directory. We do it there, because
during readconf_main() some expansion takes place already. */
issues (currently about tls_advertise_hosts and keep_environment not being
defined) */
-readconf_main(checking || list_options);
+ {
+#ifdef MEASURE_TIMING
+ struct timeval t0, diff;
+ (void)gettimeofday(&t0, NULL);
+#endif
+
+ readconf_main(checking || list_options);
+
+#ifdef MEASURE_TIMING
+ report_time_since(&t0, US"readconf_main (delta)");
+#endif
+ }
/* Now in directory "/" */
for later interrogation. */
if (real_uid == root_uid || real_uid == exim_uid || real_gid == exim_gid)
- admin_user = TRUE;
+ f.admin_user = TRUE;
else
- {
- int i, j;
- for (i = 0; i < group_count && !admin_user; i++)
+ for (int i = 0; i < group_count && !f.admin_user; i++)
if (group_list[i] == exim_gid)
- admin_user = TRUE;
+ f.admin_user = TRUE;
else if (admin_groups)
- for (j = 1; j <= (int)admin_groups[0] && !admin_user; j++)
+ for (int j = 1; j <= (int)admin_groups[0] && !f.admin_user; j++)
if (admin_groups[j] == group_list[i])
- admin_user = TRUE;
- }
+ f.admin_user = TRUE;
/* Another group of privileged users are the trusted users. These are root,
exim, and any caller matching trusted_users or trusted_groups. Trusted callers
other message parameters as well. */
if (real_uid == root_uid || real_uid == exim_uid)
- trusted_caller = TRUE;
+ f.trusted_caller = TRUE;
else
{
- int i, j;
-
if (trusted_users)
- for (i = 1; i <= (int)trusted_users[0] && !trusted_caller; i++)
+ for (int i = 1; i <= (int)trusted_users[0] && !f.trusted_caller; i++)
if (trusted_users[i] == real_uid)
- trusted_caller = TRUE;
+ f.trusted_caller = TRUE;
if (trusted_groups)
- for (i = 1; i <= (int)trusted_groups[0] && !trusted_caller; i++)
+ for (int i = 1; i <= (int)trusted_groups[0] && !f.trusted_caller; i++)
if (trusted_groups[i] == real_gid)
- trusted_caller = TRUE;
- else for (j = 0; j < group_count && !trusted_caller; j++)
+ f.trusted_caller = TRUE;
+ else for (int j = 0; j < group_count && !f.trusted_caller; j++)
if (trusted_groups[i] == group_list[j])
- trusted_caller = TRUE;
+ f.trusted_caller = TRUE;
}
/* At this point, we know if the user is privileged and some command-line
options become possibly impermissible, depending upon the configuration file. */
-if (checking && commandline_checks_require_admin && !admin_user) {
- fprintf(stderr, "exim: those command-line flags are set to require admin\n");
- exit(EXIT_FAILURE);
-}
+if (checking && commandline_checks_require_admin && !f.admin_user)
+ exim_fail("exim: those command-line flags are set to require admin\n");
/* Handle the decoding of logging options. */
DEBUG(D_any)
{
- int i;
debug_printf("configuration file is %s\n", config_main_filename);
debug_printf("log selectors =");
- for (i = 0; i < log_selector_size; i++)
+ for (int i = 0; i < log_selector_size; i++)
debug_printf(" %08x", log_selector[i]);
debug_printf("\n");
}
/* If domain literals are not allowed, check the sender address that was
supplied with -f. Ditto for a stripped trailing dot. */
-if (sender_address != NULL)
+if (sender_address)
{
if (sender_address[sender_address_domain] == '[' && !allow_domain_literals)
- {
- fprintf(stderr, "exim: bad -f address \"%s\": domain literals not "
+ exim_fail("exim: bad -f address \"%s\": domain literals not "
"allowed\n", sender_address);
- return EXIT_FAILURE;
- }
if (f_end_dot && !strip_trailing_dot)
- {
- fprintf(stderr, "exim: bad -f address \"%s.\": domain is malformed "
+ exim_fail("exim: bad -f address \"%s.\": domain is malformed "
"(trailing dot not allowed)\n", sender_address);
- return EXIT_FAILURE;
- }
}
/* See if an admin user overrode our logging. */
-if (cmdline_syslog_name != NULL)
- {
- if (admin_user)
+if (cmdline_syslog_name)
+ if (f.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_fail(
"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
"syslog_processname is longer than 32 chars: aborting");
if (log_oneline)
- if (admin_user)
+ if (f.admin_user)
{
log_write(0, LOG_MAIN, "%s", log_oneline);
return EXIT_SUCCESS;
*/
#ifdef EXIM_TMPDIR
- {
- uschar **p;
- if (environ) for (p = USS environ; *p; p++)
+ if (environ) for (uschar ** p = USS environ; *p; p++)
if (Ustrncmp(*p, "TMPDIR=", 7) == 0 && Ustrcmp(*p+7, EXIM_TMPDIR) != 0)
{
uschar * newp = store_malloc(Ustrlen(EXIM_TMPDIR) + 8);
*p = newp;
DEBUG(D_any) debug_printf("reset TMPDIR=%s in environment\n", EXIM_TMPDIR);
}
- }
#endif
/* Timezone handling. If timezone_string is "utc", set a flag to cause all
timestamps_utc is set, because then all times are in UTC anyway. */
if (timezone_string && strcmpic(timezone_string, US"UTC") == 0)
- timestamps_utc = TRUE;
+ f.timestamps_utc = TRUE;
else
{
uschar *envtz = US getenv("TZ");
trusted configuration file (when deliver_drop_privilege is false). */
if ( removed_privilege
- && (!trusted_config || opt_D_used)
+ && (!f.trusted_config || opt_D_used)
&& real_uid == exim_uid)
if (deliver_drop_privilege)
- really_exim = TRUE; /* let logging work normally */
+ f.really_exim = TRUE; /* let logging work normally */
else
log_write(0, LOG_MAIN|LOG_PANIC,
"exim user lost privilege for using %s option",
- trusted_config? "-D" : "-C");
+ f.trusted_config? "-D" : "-C");
/* Start up Perl interpreter if Perl support is configured and there is a
perl_startup option, and the configuration or the command line specifies
{
uschar *errstr;
DEBUG(D_any) debug_printf("Starting Perl interpreter\n");
- errstr = init_perl(opt_perl_startup);
- if (errstr != NULL)
- {
- fprintf(stderr, "exim: error in perl_startup code: %s\n", errstr);
- return EXIT_FAILURE;
- }
+ if ((errstr = init_perl(opt_perl_startup)))
+ exim_fail("exim: error in perl_startup code: %s\n", errstr);
opt_perl_started = TRUE;
}
#endif /* EXIM_PERL */
verifying/testing addresses or expansions. */
if ( (debug_selector & D_any || LOGGING(arguments))
- && really_exim && !list_options && !checking)
+ && f.really_exim && !list_options && !checking)
{
- int i;
uschar *p = big_buffer;
- Ustrcpy(p, "cwd= (failed)");
+ Ustrcpy(p, US"cwd= (failed)");
if (!initial_cwd)
p += 13;
(void)string_format(p, big_buffer_size - (p - big_buffer), " %d args:", argc);
while (*p) p++;
- for (i = 0; i < argc; i++)
+ for (int i = 0; i < argc; i++)
{
int len = Ustrlen(argv[i]);
const uschar *printing;
uschar *quote;
if (p + len + 8 >= big_buffer + big_buffer_size)
{
- Ustrcpy(p, " ...");
+ Ustrcpy(p, US" ...");
log_write(0, LOG_MAIN, "%s", big_buffer);
- Ustrcpy(big_buffer, "...");
+ Ustrcpy(big_buffer, US"...");
p = big_buffer + 3;
}
printing = string_printing(argv[i]);
(argv[1] == NULL)? US"" : argv[1]);
execv(CS argv[0], (char *const *)argv);
- fprintf(stderr, "exim: exec failed: %s\n", strerror(errno));
- exit(EXIT_FAILURE);
+ exim_fail("exim: exec failed: %s\n", strerror(errno));
}
else
{
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");
+if (f.trusted_caller) DEBUG(D_any) debug_printf("trusted user\n");
+if (f.admin_user) DEBUG(D_any) debug_printf("admin user\n");
/* Only an admin user may start the daemon or force a queue run in the default
configuration, but the queue run restriction can be relaxed. Only an admin
count. Only an admin user can use the test interface to scan for email
(because Exim will be in the spool dir and able to look at mails). */
-if (!admin_user)
+if (!f.admin_user)
{
BOOL debugset = (debug_selector & ~D_v) != 0;
- if (deliver_give_up || daemon_listen || malware_test_file ||
- (count_queue && queue_list_requires_admin) ||
- (list_queue && queue_list_requires_admin) ||
- (queue_interval >= 0 && prod_requires_admin) ||
- (debugset && !running_in_test_harness))
- {
- fprintf(stderr, "exim:%s permission denied\n", debugset? " debugging" : "");
- exit(EXIT_FAILURE);
- }
+ if ( deliver_give_up || f.daemon_listen || malware_test_file
+ || count_queue && queue_list_requires_admin
+ || list_queue && queue_list_requires_admin
+ || queue_interval >= 0 && prod_requires_admin
+ || queue_name_dest && prod_requires_admin
+ || debugset && !f.running_in_test_harness
+ )
+ exim_fail("exim:%s permission denied\n", debugset? " debugging" : "");
}
/* If the real user is not root or the exim uid, the argument for passing
if (real_uid != root_uid && real_uid != exim_uid &&
(continue_hostname != NULL ||
- (dont_deliver &&
- (queue_interval >= 0 || daemon_listen || msg_action_arg > 0)
- )) && !running_in_test_harness)
- {
- fprintf(stderr, "exim: Permission denied\n");
- return EXIT_FAILURE;
- }
+ (f.dont_deliver &&
+ (queue_interval >= 0 || f.daemon_listen || msg_action_arg > 0)
+ )) && !f.running_in_test_harness)
+ exim_fail("exim: Permission denied\n");
/* If the caller is not trusted, certain arguments are ignored when running for
real, but are permitted when checking things (-be, -bv, -bt, -bh, -bf, -bF).
Note that authority for performing certain actions on messages is tested in the
queue_action() function. */
-if (!trusted_caller && !checking)
+if (!f.trusted_caller && !checking)
{
sender_host_name = sender_host_address = interface_address =
sender_ident = received_protocol = NULL;
/* If the caller is trusted, then they can use -G to suppress_local_fixups. */
if (flag_G)
{
- if (trusted_caller)
+ if (f.trusted_caller)
{
- suppress_local_fixups = suppress_local_fixups_default = TRUE;
+ f.suppress_local_fixups = f.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;
- }
+ exim_fail("exim: permission denied (-G requires a trusted user)\n");
}
/* If an SMTP message is being received check to see if the standard input is a
if (real_uid == root_uid || real_uid == exim_uid || interface_port < 1024)
{
- is_inetd = TRUE;
+ f.is_inetd = TRUE;
sender_host_address = host_ntoa(-1, (struct sockaddr *)(&inetd_sock),
NULL, &sender_host_port);
if (mua_wrapper) log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Input from "
"inetd is not supported when mua_wrapper is set");
}
else
- {
- fprintf(stderr,
+ exim_fail(
"exim: Permission denied (unprivileged user, unprivileged port)\n");
- return EXIT_FAILURE;
- }
}
}
}
root. There will be further calls later for each message received. */
#ifdef LOAD_AVG_NEEDS_ROOT
-if (receiving_message &&
- (queue_only_load >= 0 ||
- (is_inetd && smtp_load_reserve >= 0)
- ))
- {
+if ( receiving_message
+ && (queue_only_load >= 0 || (f.is_inetd && smtp_load_reserve >= 0)))
load_average = OS_GETLOADAVG();
- }
#endif
/* The queue_only configuration option can be overridden by -odx on the command
if (!unprivileged && /* originally had root AND */
!removed_privilege && /* still got root AND */
- !daemon_listen && /* not starting the daemon */
+ !f.daemon_listen && /* not starting the daemon */
queue_interval <= 0 && /* (either kind of daemon) */
( /* AND EITHER */
deliver_drop_privilege || /* requested unprivileged */
queue_interval < 0 && /* not running the queue */
(msg_action_arg < 0 || /* and */
msg_action != MSG_DELIVER) && /* not delivering and */
- (!checking || !address_test_mode) /* not address checking */
+ (!checking || !f.address_test_mode) /* not address checking */
) ) )
exim_setugid(exim_uid, exim_gid, TRUE, US"privilege not needed");
else
{
int rv;
+ DEBUG(D_any) debug_printf("dropping to exim gid; retaining priv uid\n");
rv = setgid(exim_gid);
/* Impact of failure is that some stuff might end up with an incorrect group.
We track this for failures from root, since any attempt to change privilege
no need to complain then. */
if (rv == -1)
if (!(unprivileged || removed_privilege))
- {
- fprintf(stderr,
- "exim: changing group failed: %s\n", strerror(errno));
- exit(EXIT_FAILURE);
- }
+ exim_fail("exim: changing group failed: %s\n", strerror(errno));
else
DEBUG(D_any) debug_printf("changing group to %ld failed: %s\n",
(long int)exim_gid, strerror(errno));
if (count_queue)
{
set_process_info("counting the queue");
- queue_count();
+ fprintf(stdout, "%u\n", queue_count());
exit(EXIT_SUCCESS);
}
int yield = EXIT_SUCCESS;
set_process_info("acting on specified messages");
+ /* ACL definitions may be needed when removing a message (-Mrm) because
+ event_action gets expanded */
+
+ if (msg_action == MSG_REMOVE)
+ readconf_rest();
+
if (!one_msg_action)
{
for (i = msg_action_arg; i < argc; i++)
if (!queue_action(argv[i], msg_action, NULL, 0, 0))
yield = EXIT_FAILURE;
+ switch (msg_action)
+ {
+ case MSG_REMOVE: case MSG_FREEZE: case MSG_THAW: break;
+ default: printf("\n"); break;
+ }
}
else if (!queue_action(argv[msg_action_arg], msg_action, argv, argc,
}
/* We used to set up here to skip reading the ACL section, on
- (msg_action_arg > 0 || (queue_interval == 0 && !daemon_listen)
+ (msg_action_arg > 0 || (queue_interval == 0 && !f.daemon_listen)
Now, since the intro of the ${acl } expansion, ACL definitions may be
needed in transports so we lost the optimisation. */
-readconf_rest();
+ {
+#ifdef MEASURE_TIMING
+ struct timeval t0, diff;
+ (void)gettimeofday(&t0, NULL);
+#endif
-/* The configuration data will have been read into POOL_PERM because we won't
-ever want to reset back past it. Change the current pool to POOL_MAIN. In fact,
-this is just a bit of pedantic tidiness. It wouldn't really matter if the
-configuration were read into POOL_MAIN, because we don't do any resets till
-later on. However, it seems right, and it does ensure that both pools get used.
-*/
+ readconf_rest();
-store_pool = POOL_MAIN;
+#ifdef MEASURE_TIMING
+ report_time_since(&t0, US"readconf_rest (delta)");
+#endif
+ }
/* Handle the -brt option. This is for checking out retry configurations.
The next three arguments are a domain name or a complete address, and
printf("No retry information found\n");
else
{
- retry_rule *r;
more_errno = yield->more_errno;
printf("Retry rule: %s ", yield->pattern);
printf("auth_failed ");
else printf("* ");
- for (r = yield->rules; r; r = r->next)
+ for (retry_rule * r = yield->rules; r; r = r->next)
{
printf("%c,%s", r->rule, readconf_printtime(r->timeout)); /* Do not */
printf(",%s", readconf_printtime(r->p1)); /* amalgamate */
}
-/* Initialise subsystems as required */
-#ifndef DISABLE_DKIM
-dkim_exim_init();
-#endif
-deliver_init();
+/* Initialise subsystems as required. */
+tcp_init();
/* Handle a request to deliver one or more messages that are already on the
queue. Values of msg_action other than MSG_DELIVER and MSG_LOAD are dealt with
if (msg_action_arg > 0 && msg_action != MSG_LOAD)
{
- if (prod_requires_admin && !admin_user)
+ if (prod_requires_admin && !f.admin_user)
{
fprintf(stderr, "exim: Permission denied\n");
exim_exit(EXIT_FAILURE, US"main");
}
set_process_info("delivering specified messages");
- if (deliver_give_up) forced_delivery = deliver_force_thaw = TRUE;
+ if (deliver_give_up) forced_delivery = f.deliver_force_thaw = TRUE;
for (i = msg_action_arg; i < argc; i++)
{
int status;
pid_t pid;
if (i == argc - 1)
(void)deliver_message(argv[i], forced_delivery, deliver_give_up);
- else if ((pid = fork()) == 0)
+ else if ((pid = exim_fork(US"cmdline-delivery")) == 0)
{
(void)deliver_message(argv[i], forced_delivery, deliver_give_up);
- _exit(EXIT_SUCCESS);
+ exim_underbar_exit(EXIT_SUCCESS, US"cmdline-delivery");
}
else if (pid < 0)
{
/* If only a single queue run is requested, without SMTP listening, we can just
turn into a queue runner, with an optional starting message id. */
-if (queue_interval == 0 && !daemon_listen)
+if (queue_interval == 0 && !f.daemon_listen)
{
DEBUG(D_queue_run) debug_printf("Single queue run%s%s%s%s\n",
- (start_queue_run_id == NULL)? US"" : US" starting at ",
- (start_queue_run_id == NULL)? US"" : start_queue_run_id,
- (stop_queue_run_id == NULL)? US"" : US" stopping at ",
- (stop_queue_run_id == NULL)? US"" : stop_queue_run_id);
+ start_queue_run_id ? US" starting at " : US"",
+ start_queue_run_id ? start_queue_run_id: US"",
+ stop_queue_run_id ? US" stopping at " : US"",
+ stop_queue_run_id ? stop_queue_run_id : US"");
if (*queue_name)
set_process_info("running the '%s' queue (single queue run)", queue_name);
else
if (!originator_name)
{
- if (!sender_address || (!trusted_caller && filter_test == FTEST_NONE))
+ if (!sender_address || (!f.trusted_caller && filter_test == FTEST_NONE))
{
uschar *name = US pw->pw_gecos;
uschar *amp = Ustrchr(name, '&');
configuration specifies something to use. When running in the test harness,
any setting of unknown_login overrides the actual name. */
-if (originator_login == NULL || running_in_test_harness)
+if (originator_login == NULL || f.running_in_test_harness)
{
if (unknown_login != NULL)
{
for incoming messages via the daemon. The daemon cannot be run in mua_wrapper
mode. */
-if (daemon_listen || inetd_wait_mode || queue_interval > 0)
+if (f.daemon_listen || f.inetd_wait_mode || queue_interval > 0)
{
if (mua_wrapper)
{
log_write(0, LOG_MAIN|LOG_PANIC_DIE, "Daemon cannot be run when "
"mua_wrapper is set");
}
+
+# ifndef DISABLE_TLS
+ /* This also checks that the library linkage is working and we can call
+ routines in it, so call even if tls_require_ciphers is unset */
+ {
+# ifdef MEASURE_TIMING
+ struct timeval t0, diff;
+ (void)gettimeofday(&t0, NULL);
+# endif
+ if (!tls_dropprivs_validate_require_cipher(FALSE))
+ exit(1);
+# ifdef MEASURE_TIMING
+ report_time_since(&t0, US"validate_ciphers (delta)");
+# endif
+ }
+#endif
+
daemon_go();
}
the caller. This will get overwritten below for an inetd call. If a trusted
caller has set it empty, unset it. */
-if (sender_ident == NULL) sender_ident = originator_login;
- else if (sender_ident[0] == 0) sender_ident = NULL;
+if (!sender_ident) sender_ident = originator_login;
+else if (!*sender_ident) sender_ident = NULL;
/* Handle the -brw option, which is for checking out rewriting rules. Cause log
writes (on errors) to go to stderr instead. Can't do this earlier, as want the
if (test_rewrite_arg >= 0)
{
- really_exim = FALSE;
+ f.really_exim = FALSE;
if (test_rewrite_arg >= argc)
{
printf("-brw needs an address argument\n");
unless a trusted caller supplies a sender address with -f, or is passing in the
message via SMTP (inetd invocation or otherwise). */
-if ((sender_address == NULL && !smtp_input) ||
- (!trusted_caller && filter_test == FTEST_NONE))
+if ( !sender_address && !smtp_input
+ || !f.trusted_caller && filter_test == FTEST_NONE)
{
- sender_local = TRUE;
+ f.sender_local = TRUE;
/* A trusted caller can supply authenticated_sender and authenticated_id
via -oMas and -oMai and if so, they will already be set. Otherwise, force
defaults except when host checking. */
- if (authenticated_sender == NULL && !host_checking)
+ if (!authenticated_sender && !host_checking)
authenticated_sender = string_sprintf("%s@%s", originator_login,
qualify_domain_sender);
- if (authenticated_id == NULL && !host_checking)
+ if (!authenticated_id && !host_checking)
authenticated_id = originator_login;
}
specify a sender address for SMTP input, we leave sender_address unset. This
causes the MAIL commands to be honoured. */
-if ((!smtp_input && sender_address == NULL) ||
- !receive_check_set_sender(sender_address))
+if ( !smtp_input && !sender_address
+ || !receive_check_set_sender(sender_address))
{
/* Either the caller is not permitted to set a general sender, or this is
non-SMTP input and the trusted caller has not set a sender. If there is no
!checking)) /* Not running tests, including filter tests */
{
sender_address = originator_login;
- sender_address_forced = FALSE;
+ f.sender_address_forced = FALSE;
sender_address_domain = 0;
}
}
/* Remember whether an untrusted caller set the sender address */
-sender_set_untrusted = sender_address != originator_login && !trusted_caller;
+f.sender_set_untrusted = sender_address != originator_login && !f.trusted_caller;
/* Ensure that the sender address is fully qualified unless it is the empty
address, which indicates an error message, or doesn't exist (root caller, smtp
interface, no -f argument). */
-if (sender_address != NULL && sender_address[0] != 0 &&
- sender_address_domain == 0)
+if (sender_address && *sender_address && sender_address_domain == 0)
sender_address = string_sprintf("%s@%s", local_part_quote(sender_address),
qualify_domain_sender);
stdin. Set debug_level to at least D_v to get full output for address testing.
*/
-if (verify_address_mode || address_test_mode)
+if (verify_address_mode || f.address_test_mode)
{
int exit_value = 0;
int flags = vopt_qualify;
{
while (recipients_arg < argc)
{
- uschar *s = argv[recipients_arg++];
- while (*s != 0)
+ /* Supplied addresses are tainted since they come from a user */
+ uschar * s = string_copy_taint(argv[recipients_arg++], TRUE);
+ while (*s)
{
BOOL finished = FALSE;
uschar *ss = parse_find_address_end(s, FALSE);
test_address(s, flags, &exit_value);
s = ss;
if (!finished)
- while (*(++s) != 0 && (*s == ',' || isspace(*s)));
+ while (*++s == ',' || isspace(*s)) ;
}
}
}
else for (;;)
{
- uschar *s = get_stdinput(NULL, NULL);
- if (s == NULL) break;
- test_address(s, flags, &exit_value);
+ uschar * s = get_stdinput(NULL, NULL);
+ if (!s) break;
+ test_address(string_copy_taint(s, TRUE), flags, &exit_value);
}
route_tidyup();
if (msg_action_arg > 0 && msg_action == MSG_LOAD)
{
uschar spoolname[256]; /* Not big_buffer; used in spool_read_header() */
- if (!admin_user)
- {
- fprintf(stderr, "exim: permission denied\n");
- exit(EXIT_FAILURE);
- }
+ if (!f.admin_user)
+ exim_fail("exim: permission denied\n");
message_id = argv[msg_action_arg];
(void)string_format(spoolname, sizeof(spoolname), "%s-H", message_id);
if ((deliver_datafile = spool_open_datafile(message_id)) < 0)
int save_stdin = dup(0);
int fd = Uopen(expansion_test_message, O_RDONLY, 0);
if (fd < 0)
- {
- fprintf(stderr, "exim: failed to open %s: %s\n", expansion_test_message,
+ exim_fail("exim: failed to open %s: %s\n", expansion_test_message,
strerror(errno));
- return EXIT_FAILURE;
- }
(void) dup2(fd, 0);
filter_test = FTEST_USER; /* Fudge to make it look like filter test */
message_ended = END_NOTENDED;
/* Only admin users may see config-file macros this way */
- if (!admin_user) macros_user = macros = mlast = NULL;
+ if (!f.admin_user) macros_user = macros = mlast = NULL;
/* Allow $recipients for this testing */
- enable_dollar_recipients = TRUE;
+ f.enable_dollar_recipients = TRUE;
/* Expand command line items */
uschar *nah = expand_string(raw_active_hostname);
if (nah == NULL)
{
- if (!expand_string_forcedfail)
+ if (!f.expand_string_forcedfail)
log_write(0, LOG_MAIN|LOG_PANIC_DIE, "failed to expand \"%s\" "
"(smtp_active_hostname): %s", raw_active_hostname,
expand_string_message);
if (!sender_ident_set)
{
sender_ident = NULL;
- if (running_in_test_harness && sender_host_port != 0 &&
- interface_address != NULL && interface_port != 0)
- verify_get_ident(1413);
+ if (f.running_in_test_harness && sender_host_port
+ && interface_address && interface_port)
+ verify_get_ident(1223); /* note hardwired port number */
}
/* In case the given address is a non-canonical IPv6 address, canonicalize
it. The code works for both IPv4 and IPv6, as it happens. */
size = host_aton(sender_host_address, x);
- sender_host_address = store_get(48); /* large enough for full IPv6 */
+ sender_host_address = store_get(48, FALSE); /* large enough for full IPv6 */
(void)host_nmtoa(size, x, -1, sender_host_address, ':');
/* Now set up for testing */
smtp_input = TRUE;
smtp_in = stdin;
smtp_out = stdout;
- sender_local = FALSE;
- sender_host_notsocket = TRUE;
+ f.sender_local = FALSE;
+ f.sender_host_notsocket = TRUE;
debug_file = stderr;
debug_fd = fileno(debug_file);
fprintf(stdout, "\n**** SMTP testing session as if from host %s\n"
if (smtp_start_session())
{
- for (reset_point = store_get(0); ; store_reset(reset_point))
+ for (; (reset_point = store_mark()); store_reset(reset_point))
{
if (smtp_setup_msg() <= 0) break;
if (!receive_msg(FALSE)) break;
if (mua_wrapper)
{
- synchronous_delivery = TRUE;
+ f.synchronous_delivery = TRUE;
arg_error_handling = ERRORS_STDERR;
remote_max_parallel = 1;
deliver_drop_privilege = TRUE;
- queue_smtp = FALSE;
+ f.queue_smtp = FALSE;
queue_smtp_domains = NULL;
#ifdef SUPPORT_I18N
message_utf8_downconvert = -1; /* convert-if-needed */
logging being sent down the socket and make an identd call to get the
sender_ident. */
-else if (is_inetd)
+else if (f.is_inetd)
{
(void)fclose(stderr);
exim_nullstd(); /* Re-open to /dev/null */
host_build_sender_fullhost();
set_process_info("handling incoming connection from %s via -oMa",
sender_fullhost);
- sender_host_notsocket = TRUE;
+ f.sender_host_notsocket = TRUE;
}
/* Otherwise, set the sender host as unknown except for inetd calls. This
prevents host checking in the case of -bs not from inetd and also for -bS. */
-else if (!is_inetd) sender_host_unknown = TRUE;
+else if (!f.is_inetd) f.sender_host_unknown = TRUE;
/* If stdout does not exist, then dup stdin to stdout. This can happen
if exim is started from inetd. In this case fd 0 will be set to the socket,
if (smtp_input)
{
- if (!is_inetd) set_process_info("accepting a local %sSMTP message from <%s>",
+ if (!f.is_inetd) set_process_info("accepting a local %sSMTP message from <%s>",
smtp_batched_input? "batched " : "",
(sender_address!= NULL)? sender_address : originator_login);
}
error code is given.) */
if ((!smtp_input || smtp_batched_input) && !receive_check_fs(0))
- {
- fprintf(stderr, "exim: insufficient disk space\n");
- return EXIT_FAILURE;
- }
+ exim_fail("exim: insufficient disk space\n");
/* If this is smtp input of any kind, real or batched, handle the start of the
SMTP session.
As a consequence of this, the waitpid() below is now excluded if we are sure
that SIG_IGN works. */
-if (!synchronous_delivery)
+if (!f.synchronous_delivery)
{
#ifdef SA_NOCLDWAIT
struct sigaction act;
/* Save the current store pool point, for resetting at the start of
each message, and save the real sender address, if any. */
-reset_point = store_get(0);
real_sender_address = sender_address;
/* Loop to receive messages; receive_msg() returns TRUE if there are more
while (more)
{
+ reset_point = store_mark();
message_id[0] = 0;
/* Handle the SMTP case; call smtp_setup_mst() to deal with the initial SMTP
if (smtp_batched_input && acl_not_smtp_start != NULL)
{
uschar *user_msg, *log_msg;
- enable_dollar_recipients = TRUE;
+ f.enable_dollar_recipients = TRUE;
(void)acl_check(ACL_WHERE_NOTSMTP_START, NULL, acl_not_smtp_start,
&user_msg, &log_msg);
- enable_dollar_recipients = FALSE;
+ f.enable_dollar_recipients = FALSE;
}
/* Now get the data for the message */
else
{
- int i;
int rcount = 0;
int count = argc - recipients_arg;
uschar **list = argv + recipients_arg;
/* These options cannot be changed dynamically for non-SMTP messages */
- active_local_sender_retain = local_sender_retain;
- active_local_from_check = local_from_check;
+ f.active_local_sender_retain = local_sender_retain;
+ f.active_local_from_check = local_from_check;
/* Save before any rewriting */
raw_sender = string_copy(sender_address);
- /* Loop for each argument */
+ /* Loop for each argument (supplied by user hence tainted) */
- for (i = 0; i < count; i++)
+ for (int i = 0; i < count; i++)
{
int start, end, domain;
- uschar *errmess;
- uschar *s = list[i];
+ uschar * errmess;
+ uschar * s = string_copy_taint(list[i], TRUE);
/* Loop for each comma-separated address */
allow_utf8_domains = b;
}
#endif
- if (domain == 0 && !allow_unqualified_recipient)
+ if (domain == 0 && !f.allow_unqualified_recipient)
{
recipient = NULL;
errmess = US"unqualified recipient address not allowed";
}
}
- receive_add_recipient(recipient, -1);
+ receive_add_recipient(string_copy_taint(recipient, TRUE), -1);
s = ss;
if (!finished)
while (*(++s) != 0 && (*s == ',' || isspace(*s)));
DEBUG(D_receive)
{
- int i;
if (sender_address != NULL) debug_printf("Sender: %s\n", sender_address);
if (recipients_list != NULL)
{
debug_printf("Recipients:\n");
- for (i = 0; i < recipients_count; i++)
+ for (int i = 0; i < recipients_count; i++)
debug_printf(" %s\n", recipients_list[i].address);
}
}
if (acl_not_smtp_start)
{
uschar *user_msg, *log_msg;
- enable_dollar_recipients = TRUE;
+ f.enable_dollar_recipients = TRUE;
(void)acl_check(ACL_WHERE_NOTSMTP_START, NULL, acl_not_smtp_start,
&user_msg, &log_msg);
- enable_dollar_recipients = FALSE;
+ f.enable_dollar_recipients = FALSE;
}
/* Pause for a while waiting for input. If none received in that time,
are ignored. */
if (mua_wrapper)
- local_queue_only = queue_only_policy = deliver_freeze = FALSE;
+ local_queue_only = f.queue_only_policy = f.deliver_freeze = FALSE;
/* Log the queueing here, when it will get a message id attached, but
not if queue_only is set (case 0). Case 1 doesn't happen here (too many
}
}
- else if (queue_only_policy || deliver_freeze)
+ else if (f.queue_only_policy || f.deliver_freeze)
cancel_cutthrough_connection(TRUE, US"no delivery; queueing");
/* Else do the delivery unless the ACL or local_scan() called for queue only
pid_t pid;
search_tidyup();
- if ((pid = fork()) == 0)
+ if ((pid = exim_fork(US"local-accept delivery")) == 0)
{
int rc;
close_unwanted(); /* Close unwanted file descriptors and TLS */
rc = deliver_message(message_id, FALSE, FALSE);
search_tidyup();
- _exit((!mua_wrapper || rc == DELIVER_MUA_SUCCEEDED)?
- EXIT_SUCCESS : EXIT_FAILURE);
+ exim_underbar_exit(!mua_wrapper || rc == DELIVER_MUA_SUCCEEDED
+ ? EXIT_SUCCESS : EXIT_FAILURE, US"cmdline-delivery");
}
if (pid < 0)
/* In the parent, wait if synchronous delivery is required. This will
always be the case in MUA wrapper mode. */
- if (synchronous_delivery)
+ if (f.synchronous_delivery)
{
int status;
while (wait(&status) != pid);
callout_address = NULL;
sending_ip_address = NULL;
acl_var_m = NULL;
- { int i; for(i=0; i<REGEX_VARS; i++) regex_vars[i] = NULL; }
+ for(int i = 0; i < REGEX_VARS; i++) regex_vars[i] = NULL;
store_reset(reset_point);
}
git://git.exim.org / exim.git / blobdiff