/*
 * Copyright (C) 1996-2007,2010,2013 Michael R. Elkins <me@mutt.org>
 * Copyright (C) 1999-2007 Thomas Roessler <roessler@does-not-exist.org>
 * Copyright (C) 2004 g10 Code GmbH
 *
 *     This program is free software; you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation; either version 2 of the License, or
 *     (at your option) any later version.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with this program; if not, write to the Free Software
 *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

#define MAIN_C 1

#if HAVE_CONFIG_H
# include "config.h"
#endif

#include "mutt.h"
#include "mutt_curses.h"
#include "keymap.h"
#include "mailbox.h"
#include "url.h"
#include "mutt_crypt.h"
#include "mutt_idna.h"
#include "send.h"
#include "background.h"

#ifdef USE_SIDEBAR
#include "sidebar.h"
#endif

#ifdef USE_SASL_CYRUS
#include "mutt_sasl.h"
#endif

#ifdef USE_SASL_GNU
#include "mutt_sasl_gnu.h"
#endif

#ifdef USE_IMAP
#include "imap/imap.h"
#endif

#ifdef USE_HCACHE
#include "hcache.h"
#endif

#ifdef USE_INOTIFY
#include "monitor.h"
#endif

#ifdef USE_AUTOCRYPT
#include "autocrypt/autocrypt.h"
#endif

#include <string.h>
#include <stdlib.h>
#include <locale.h>
#include <unistd.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/utsname.h>

#ifdef HAVE_GETOPT_H
#include <getopt.h>
#endif

#ifdef HAVE_STRINGPREP_H
#include <stringprep.h>
#elif defined(HAVE_IDN_STRINGPREP_H)
#include <idn/stringprep.h>
#endif

static const char *ReachingUs = N_("\
To contact the developers, please mail to <mutt-dev@mutt.org>.\n\
To report a bug, please contact the Mutt maintainers via gitlab:\n\
    https://gitlab.com/muttmua/mutt/issues\n");

static const char *Notice = N_("\
Copyright (C) 1996-2026 Michael R. Elkins and others.\n\
Mutt comes with ABSOLUTELY NO WARRANTY; for details type `mutt -vv'.\n\
Mutt is free software, and you are welcome to redistribute it\n\
under certain conditions; type `mutt -vv' for details.\n");

static const char Copyright[] = "\
Copyright (C) 1996-2016 Michael R. Elkins <me@mutt.org>\n\
Copyright (C) 1996-2002 Brandon Long <blong@fiction.net>\n\
Copyright (C) 1997-2009 Thomas Roessler <roessler@does-not-exist.org>\n\
Copyright (C) 1998-2005 Werner Koch <wk@isil.d.shuttle.de>\n\
Copyright (C) 1999-2017 Brendan Cully <brendan@kublai.com>\n\
Copyright (C) 1999-2002 Tommi Komulainen <Tommi.Komulainen@iki.fi>\n\
Copyright (C) 2000-2004 Edmund Grimley Evans <edmundo@rano.org>\n\
Copyright (C) 2006-2009 Rocco Rutte <pdmef@gmx.net>\n\
Copyright (C) 2014-2026 Kevin J. McCarthy <kevin@8t8.us>\n";

static const char *Thanks = N_("\
Many others not mentioned here contributed code, fixes,\n\
and suggestions.\n");

static const char *Licence = N_("\
    This program is free software; you can redistribute it and/or modify\n\
    it under the terms of the GNU General Public License as published by\n\
    the Free Software Foundation; either version 2 of the License, or\n\
    (at your option) any later version.\n\
\n\
    This program is distributed in the hope that it will be useful,\n\
    but WITHOUT ANY WARRANTY; without even the implied warranty of\n\
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n\
    GNU General Public License for more details.\n");
static const char *Obtaining = N_("\
    You should have received a copy of the GNU General Public License\n\
    along with this program; if not, write to the Free Software\n\
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.\n\
");

char **envlist;

void mutt_exit(int code)
{
  mutt_endwin(NULL);
  exit(code);
}

static void mutt_usage(void)
{
  puts(mutt_make_version());

  puts _(
"usage: mutt [<options>] [-z] [-f <file> | -yZ]\n\
       mutt [<options>] [-Ex] [-Hi <file>] [-s <subj>] [-bc <addr>] [-a <file> [...] --] <addr> [...]\n\
       mutt [<options>] [-x] [-s <subj>] [-bc <addr>] [-a <file> [...] --] <addr> [...] < message\n\
       mutt [<options>] -p\n\
       mutt [<options>] -A <alias> [...]\n\
       mutt [<options>] -Q <query> [...]\n\
       mutt [<options>] -D\n\
       mutt -v[v]\n");

  puts _("\
options:\n\
  -A <alias>\texpand the given alias\n\
  -a <file> [...] --\tattach file(s) to the message\n\
\t\tthe list of files must be terminated with the \"--\" sequence\n\
  -b <address>\tspecify a blind carbon-copy (BCC) address\n\
  -c <address>\tspecify a carbon-copy (CC) address\n\
  -D\t\tprint the value of all variables to stdout");
#if DEBUG
  puts _("  -d <level>\tlog debugging output to ~/.muttdebug0\n\
\t\t0 => no debugging; <0 => do not rotate .muttdebug files");
#endif
  puts _(
"  -E\t\tedit the draft (-H) or include (-i) file\n\
  -e <command>\tspecify a command to be executed after initialization\n\
  -f <file>\tspecify which mailbox to read\n\
  -F <file>\tspecify an alternate muttrc file\n\
  -H <file>\tspecify a draft file to read header and body from\n\
  -i <file>\tspecify a file which Mutt should include in the body\n\
  -m <type>\tspecify a default mailbox type\n\
  -n\t\tcauses Mutt not to read the system Muttrc\n\
  -p\t\trecall a postponed message");

  puts _("\
  -Q <variable>\tquery a configuration variable\n\
  -R\t\topen mailbox in read-only mode\n\
  -s <subj>\tspecify a subject (must be in quotes if it has spaces)\n\
  -v\t\tshow version and compile-time definitions\n\
  -x\t\tsimulate the mailx send mode\n\
  -y\t\tselect a mailbox specified in your `mailboxes' list\n\
  -z\t\texit immediately if there are no messages in the mailbox\n\
  -Z\t\topen the first folder with new message, exit immediately if none\n\
  -h\t\tthis help message");

  fflush(stdout);

  if (ferror(stdout))
    exit(1);
  exit(0);
}

extern unsigned char cc_version[];
extern unsigned char cc_cflags[];
extern unsigned char configure_options[];

static char *
rstrip_in_place(char *s)
{
  char *p;

  p = &s[strlen(s)];
  if (p == s)
    return s;
  p--;
  while (p >= s && (*p == '\n' || *p == '\r'))
    *p-- = '\0';
  return s;
}

static void show_version(void)
{
  struct utsname uts;

  puts(mutt_make_version());
  puts(_(Notice));

  uname(&uts);

#ifdef _AIX
  printf("System: %s %s.%s", uts.sysname, uts.version, uts.release);
#elif defined(SCO)
  printf("System: SCO %s", uts.release);
#else
  printf("System: %s %s", uts.sysname, uts.release);
#endif

  printf(" (%s)", uts.machine);

#ifdef NCURSES_VERSION
  printf("\nncurses: %s (compiled with %s)", curses_version(), NCURSES_VERSION);
#elif defined(USE_SLANG_CURSES)
  printf("\nslang: %d", SLANG_VERSION);
#endif

#ifdef _LIBICONV_VERSION
  printf("\nlibiconv: %d.%d", _LIBICONV_VERSION >> 8,
         _LIBICONV_VERSION & 0xff);
#endif

#ifdef HAVE_LIBIDN
  printf("\nlibidn: %s (compiled with %s)", stringprep_check_version(NULL),
         STRINGPREP_VERSION);
#endif

#ifdef HAVE_LIBIDN2
  printf("\nlibidn2: %s (compiled with %s)", idn2_check_version(NULL),
         IDN2_VERSION);
#endif

#ifdef USE_HCACHE
  printf("\nhcache backend: %s", mutt_hcache_backend());
#endif

  puts("\n\nCompiler:");
  rstrip_in_place((char *)cc_version);
  puts((char *)cc_version);

  rstrip_in_place((char *)configure_options);
  printf("\nConfigure options: %s\n", (char *)configure_options);

  rstrip_in_place((char *)cc_cflags);
  printf("\nCompilation CFLAGS: %s\n", (char *)cc_cflags);

  puts(_("\nCompile options:"));

#ifdef DOMAIN
  printf("DOMAIN=\"%s\"\n", DOMAIN);
#else
  puts("-DOMAIN");
#endif

#ifdef DEBUG
  puts("+DEBUG");
#else
  puts("-DEBUG");
#endif



  puts(

#ifdef HOMESPOOL
    "+HOMESPOOL  "
#else
    "-HOMESPOOL  "
#endif

#ifdef USE_SETGID
    "+USE_SETGID  "
#else
    "-USE_SETGID  "
#endif

#ifdef USE_DOTLOCK
    "+USE_DOTLOCK  "
#else
    "-USE_DOTLOCK  "
#endif

#ifdef DL_STANDALONE
    "+DL_STANDALONE  "
#else
    "-DL_STANDALONE  "
#endif

#ifdef USE_FCNTL
    "+USE_FCNTL  "
#else
    "-USE_FCNTL  "
#endif

#ifdef USE_FLOCK
    "+USE_FLOCK   "
#else
    "-USE_FLOCK   "
#endif
    );
  puts(
#ifdef USE_POP
    "+USE_POP  "
#else
    "-USE_POP  "
#endif

#ifdef USE_IMAP
    "+USE_IMAP  "
#else
    "-USE_IMAP  "
#endif

#ifdef USE_SMTP
    "+USE_SMTP  "
#else
    "-USE_SMTP  "
#endif
    "\n"

#ifdef USE_SSL_OPENSSL
    "+USE_SSL_OPENSSL  "
#else
    "-USE_SSL_OPENSSL  "
#endif

#ifdef USE_SSL_GNUTLS
    "+USE_SSL_GNUTLS  "
#else
    "-USE_SSL_GNUTLS  "
#endif

#ifdef USE_SASL_CYRUS
    "+USE_SASL  "
#else
    "-USE_SASL  "
#endif
#ifdef USE_SASL_GNU
    "+USE_GSASL  "
#else
    "-USE_GSASL  "
#endif
#ifdef USE_GSS
    "+USE_GSS  "
#else
    "-USE_GSS  "
#endif

#if HAVE_GETADDRINFO
    "+HAVE_GETADDRINFO  "
#else
    "-HAVE_GETADDRINFO  "
#endif
    );

  puts(
#ifdef HAVE_REGCOMP
    "+HAVE_REGCOMP  "
#else
    "-HAVE_REGCOMP  "
#endif

#ifdef USE_GNU_REGEX
    "+USE_GNU_REGEX  "
#else
    "-USE_GNU_REGEX  "
#endif

    "\n"

#ifdef HAVE_COLOR
    "+HAVE_COLOR  "
#else
    "-HAVE_COLOR  "
#endif

#ifdef HAVE_START_COLOR
    "+HAVE_START_COLOR  "
#else
    "-HAVE_START_COLOR  "
#endif

#ifdef HAVE_TYPEAHEAD
    "+HAVE_TYPEAHEAD  "
#else
    "-HAVE_TYPEAHEAD  "
#endif

#ifdef HAVE_BKGDSET
    "+HAVE_BKGDSET  "
#else
    "-HAVE_BKGDSET  "
#endif

    "\n"

#ifdef HAVE_CURS_SET
    "+HAVE_CURS_SET  "
#else
    "-HAVE_CURS_SET  "
#endif

#ifdef HAVE_META
    "+HAVE_META  "
#else
    "-HAVE_META  "
#endif

#ifdef HAVE_RESIZETERM
    "+HAVE_RESIZETERM  "
#else
    "-HAVE_RESIZETERM  "
#endif

#ifdef HAVE_FUTIMENS
    "+HAVE_FUTIMENS  "
#else
    "-HAVE_FUTIMENS  "
#endif
    );

  puts(
#ifdef CRYPT_BACKEND_CLASSIC_PGP
    "+CRYPT_BACKEND_CLASSIC_PGP  "
#else
    "-CRYPT_BACKEND_CLASSIC_PGP  "
#endif
#ifdef CRYPT_BACKEND_CLASSIC_SMIME
    "+CRYPT_BACKEND_CLASSIC_SMIME  "
#else
    "-CRYPT_BACKEND_CLASSIC_SMIME  "
#endif
#ifdef CRYPT_BACKEND_GPGME
    "+CRYPT_BACKEND_GPGME  "
#else
    "-CRYPT_BACKEND_GPGME  "
#endif
    );

  puts(
#ifdef EXACT_ADDRESS
    "+EXACT_ADDRESS  "
#else
    "-EXACT_ADDRESS  "
#endif

#ifdef SUN_ATTACHMENT
    "+SUN_ATTACHMENT  "
#else
    "-SUN_ATTACHMENT  "
#endif

    "\n"

#ifdef ENABLE_NLS
    "+ENABLE_NLS  "
#else
    "-ENABLE_NLS  "
#endif

#ifdef LOCALES_HACK
    "+LOCALES_HACK  "
#else
    "-LOCALES_HACK  "
#endif

#ifdef HAVE_WC_FUNCS
    "+HAVE_WC_FUNCS  "
#else
    "-HAVE_WC_FUNCS  "
#endif

#ifdef HAVE_LANGINFO_CODESET
    "+HAVE_LANGINFO_CODESET  "
#else
    "-HAVE_LANGINFO_CODESET  "
#endif


#ifdef HAVE_LANGINFO_YESEXPR
    "+HAVE_LANGINFO_YESEXPR  "
#else
    "-HAVE_LANGINFO_YESEXPR  "
#endif

    "\n"

#if HAVE_ICONV
    "+HAVE_ICONV  "
#else
    "-HAVE_ICONV  "
#endif

#if ICONV_NONTRANS
    "+ICONV_NONTRANS  "
#else
    "-ICONV_NONTRANS  "
#endif

#if HAVE_LIBIDN
    "+HAVE_LIBIDN  "
#else
    "-HAVE_LIBIDN  "
#endif

#if HAVE_LIBIDN2
    "+HAVE_LIBIDN2  "
#else
    "-HAVE_LIBIDN2  "
#endif

#if HAVE_GETSID
    "+HAVE_GETSID  "
#else
    "-HAVE_GETSID  "
#endif

#if USE_HCACHE
    "+USE_HCACHE  "
#else
    "-USE_HCACHE  "
#endif

    "\n"

#ifdef USE_SIDEBAR
    "+USE_SIDEBAR  "
#else
    "-USE_SIDEBAR  "
#endif

#ifdef USE_COMPRESSED
    "+USE_COMPRESSED  "
#else
    "-USE_COMPRESSED  "
#endif

#ifdef USE_INOTIFY
    "+USE_INOTIFY  "
#else
    "-USE_INOTIFY  "
#endif

    );

#ifdef ISPELL
  printf("ISPELL=\"%s\"\n", ISPELL);
#else
  puts("-ISPELL");
#endif

  printf("SENDMAIL=\"%s\"\n", SENDMAIL);
  printf("MAILPATH=\"%s\"\n", MAILPATH);
  printf("PKGDATADIR=\"%s\"\n", PKGDATADIR);
  printf("SYSCONFDIR=\"%s\"\n", SYSCONFDIR);
  printf("EXECSHELL=\"%s\"\n", EXECSHELL);
#ifdef MIXMASTER
  printf("MIXMASTER=\"%s\"\n", MIXMASTER);
#else
  puts("-MIXMASTER");
#endif

  putchar('\n');

  puts(_(ReachingUs));

  mutt_print_patchlist();

  fflush(stdout);

  if (ferror(stdout))
    exit(1);
  exit(0);
}

static void start_curses(void)
{
  km_init(); /* must come before mutt_init */

#ifdef USE_SLANG_CURSES
  SLtt_Ignore_Beep = 1; /* don't do that #*$@^! annoying visual beep! */
  SLsmg_Display_Eight_Bit = 128; /* characters above this are printable */
  SLtt_set_color(0, NULL, "default", "default");
#if SLANG_VERSION >= 20000
  SLutf8_enable(-1);
#endif
#else

# if defined(HAVE_RESIZETERM) && defined(HAVE_USE_TIOCTL)
  /* mutt_resize_screen() shouldn't be fighting with ncurses */
  use_env(0);
  use_tioctl(1);
# endif

  /* should come before initscr() so that ncurses 4.2 doesn't try to install
     its own SIGWINCH handler */
  mutt_signal_init();
#endif
  if (initscr() == NULL)
  {
    puts _("Error initializing terminal.");
    exit(1);
  }
  /* slang requires the signal handlers to be set after initializing */
  mutt_signal_init();
  ci_start_color();
  keypad(stdscr, TRUE);
  cbreak();
  noecho();
  nonl();
#if HAVE_TYPEAHEAD
  typeahead(-1);       /* simulate smooth scrolling */
#endif
  init_extended_keys();
  mutt_reflow_windows();
}

#define MUTT_IGNORE  (1<<0)     /* -z */
#define MUTT_BUFFY   (1<<1)     /* -Z */
#define MUTT_NOSYSRC (1<<2)     /* -n */
#define MUTT_RO      (1<<3)     /* -R */
#define MUTT_SELECT  (1<<4)     /* -y */

int main(int argc, char **argv, char **environ)
{
  BUFFER *folder = NULL;
  BUFFER *expanded_infile = NULL;
  BUFFER *tempfile = NULL;
  char *subject = NULL;
  char *includeFile = NULL;
  char *draftFile = NULL;
  char *newMagic = NULL;
  HEADER *msg = NULL;
  LIST *attach = NULL;
  LIST *commands = NULL;
  LIST *queries = NULL;
  LIST *alias_queries = NULL;
  int sendflags = 0;
  int flags = 0;
  int version = 0;
  int i;
  int explicit_folder = 0;
  int dump_variables = 0;
  int edit_infile = 0;
#ifndef HAVE_GETOPT_H
  extern char *optarg;
  extern int optind;
#endif
  int double_dash = argc, nargc = 1;
  int exit_code = 1;
  const char *exit_endwin_msg = NULL;

  /* sanity check against stupid administrators */

  if (getegid() != getgid())
  {
    fprintf(stderr, "%s: I don't want to run with privileges!\n",
            argc ? argv[0] : "mutt");
    exit(1);
  }

  setlocale(LC_ALL, "");

#ifdef ENABLE_NLS
  /* FIXME what about the LOCALES_HACK in mutt_init() [init.c] ? */
  {
    char *domdir = getenv("TEXTDOMAINDIR");
    if (domdir && domdir[0])
      bindtextdomain(PACKAGE, domdir);
    else
      bindtextdomain(PACKAGE, MUTTLOCALEDIR);
    textdomain(PACKAGE);
  }
#endif

  mutt_error = mutt_nocurses_error;
  mutt_message = mutt_nocurses_error;
  SRAND(time(NULL));
  umask(077);

  memset(Options, 0, sizeof(Options));
  memset(QuadOptions, 0, sizeof(QuadOptions));

  /* Init envlist */
  {
    char **srcp, **dstp;
    int count = 0;
    for (srcp = environ; srcp && *srcp; srcp++)
      count++;
    envlist = safe_calloc(count+1, sizeof(char *));
    for (srcp = environ, dstp = envlist; srcp && *srcp; srcp++, dstp++)
      *dstp = safe_strdup(*srcp);
  }

  for (optind = 1; optind < double_dash; )
  {
    /* We're getopt'ing POSIXLY, so we'll be here every time getopt()
     * encounters a non-option.  That could be a file to attach
     * (all non-options between -a and --) or it could be an address
     * (which gets collapsed to the front of argv).
     */
    for (; optind < argc; optind++)
    {
      if (argv[optind][0] == '-' && argv[optind][1] != '\0')
      {
        if (argv[optind][1] == '-' && argv[optind][2] == '\0')
          double_dash = optind; /* quit outer loop after getopt */
        break;                  /* drop through to getopt */
      }

      /* non-option, either an attachment or address */
      if (attach)
        attach = mutt_add_list(attach, argv[optind]);
      else
        argv[nargc++] = argv[optind];
    }

    if ((i = getopt(argc, argv, "+A:a:b:F:f:c:Dd:Ee:H:s:i:hm:npQ:RvxyzZ")) != EOF)
      switch (i)
      {
        case 'A':
          alias_queries = mutt_add_list(alias_queries, optarg);
          break;
        case 'a':
          attach = mutt_add_list(attach, optarg);
          break;

        case 'F':
          mutt_str_replace(&Muttrc, optarg);
          break;

        case 'f':
          if (!folder)
            folder = mutt_buffer_new();
          mutt_buffer_strcpy(folder, optarg);
          explicit_folder = 1;
          break;

        case 'b':
        case 'c':
          if (!msg)
            msg = mutt_new_header();
          if (!msg->env)
            msg->env = mutt_new_envelope();
          if (i == 'b')
            msg->env->bcc = rfc822_parse_adrlist(msg->env->bcc, optarg);
          else
            msg->env->cc = rfc822_parse_adrlist(msg->env->cc, optarg);
          break;

        case 'D':
          dump_variables = 1;
          break;

        case 'd':
#ifdef DEBUG
          mutt_atoi(optarg, &debuglevel, 0);
          printf(_("Debugging at level %d.\n"), debuglevel);
#else
          printf("%s", _("DEBUG was not defined during compilation.  Ignored.\n"));
#endif
          break;

        case 'E':
          edit_infile = 1;
          break;

        case 'e':
          commands = mutt_add_list(commands, optarg);
          break;

        case 'H':
          draftFile = optarg;
          break;

        case 'i':
          includeFile = optarg;
          break;

        case 'm':
          /* should take precedence over .muttrc setting, so save it for later */
          newMagic = optarg;
          break;

        case 'n':
          flags |= MUTT_NOSYSRC;
          break;

        case 'p':
          sendflags |= SENDPOSTPONED;
          break;

        case 'Q':
          queries = mutt_add_list(queries, optarg);
          break;

        case 'R':
          flags |= MUTT_RO; /* read-only mode */
          break;

        case 's':
          subject = optarg;
          break;

        case 'v':
          version++;
          break;

        case 'x': /* mailx compatible send mode */
          sendflags |= SENDMAILX;
          break;

        case 'y': /* My special hack mode */
          flags |= MUTT_SELECT;
          break;

        case 'z':
          flags |= MUTT_IGNORE;
          break;

        case 'Z':
          flags |= MUTT_BUFFY | MUTT_IGNORE;
          break;

        default:
          mutt_usage();
      }
  }

  /* collapse remaining argv */
  while (optind < argc)
    argv[nargc++] = argv[optind++];
  optind = 1;
  argc = nargc;

  switch (version)
  {
    case 0:
      break;
    case 1:
      show_version();
      break;
    default:
      puts(mutt_make_version());
      puts(Copyright);
      puts(_(Thanks));
      puts(_(Licence));
      puts(_(Obtaining));
      puts(_(ReachingUs));
      mutt_buffer_free(&folder);
      fflush(stdout);
      if (ferror(stdout))
        exit(1);
      exit(0);
  }

  /* Check for a batch send. */
  if (!isatty(0) || queries || alias_queries || dump_variables)
  {
    set_option(OPTNOCURSES);
    sendflags = SENDBATCH;
  }

  /* Check to make sure stdout is available in curses mode. */
  if (!option(OPTNOCURSES) && !isatty(1))
    exit(1);

  /* Always create the mutt_windows because batch mode has some shared code
   * paths that end up referencing them. */
  mutt_init_windows();

  /* This must come before mutt_init() because curses needs to be started
     before calling the init_pair() function to set the color scheme.  */
  if (!option(OPTNOCURSES))
  {
    start_curses();

    /* check whether terminal status is supported (must follow curses init) */
    TSSupported = mutt_ts_capability();
  }

  /* set defaults and read init files */
  mutt_init(flags & MUTT_NOSYSRC, commands);
  mutt_free_list(&commands);

  /* Initialize crypto backends.  */
  crypt_init();

  if (newMagic)
    mx_set_magic(newMagic);

  if (queries)
  {
    for (; optind < argc; optind++)
      queries = mutt_add_list(queries, argv[optind]);
    exit_code = mutt_query_variables(queries);
    mutt_free_list(&queries);
    goto cleanup_and_exit;
  }
  if (dump_variables)
  {
    exit_code = mutt_dump_variables();
    goto cleanup_and_exit;
  }

  if (alias_queries)
  {
    ADDRESS *a;

    exit_code = 0;
    for (; optind < argc; optind++)
      alias_queries = mutt_add_list(alias_queries, argv[optind]);
    for (; alias_queries; alias_queries = alias_queries->next)
    {
      if ((a = mutt_lookup_alias(alias_queries->data)))
      {
        /* output in machine-readable form */
        mutt_addrlist_to_intl(a, NULL);
        mutt_write_address_list(a, stdout, 0, 0);
      }
      else
      {
        exit_code = 1;
        printf("%s\n", NONULL(alias_queries->data));
      }
    }
    mutt_free_list(&alias_queries);
    goto cleanup_and_exit;
  }

  if (!option(OPTNOCURSES))
  {
    SETCOLOR(MT_COLOR_NORMAL);
    clear();
    mutt_error = mutt_curses_error;
    mutt_message = mutt_curses_message;
  }

  /* Initialize autocrypt after curses messages are working,
   * because of the initial account setup screens. */
#ifdef USE_AUTOCRYPT
  if (option(OPTAUTOCRYPT))
    mutt_autocrypt_init(!(sendflags & SENDBATCH));
#endif

  /* Create the Maildir directory if it doesn't exist. */
  if (!option(OPTNOCURSES) && Maildir)
  {
    struct stat sb;
    BUFFER *fpath;
    char msg[STRING];

    fpath = mutt_buffer_pool_get();
    mutt_buffer_strcpy(fpath, Maildir);
    mutt_buffer_expand_path(fpath);
#ifdef USE_IMAP
    /* we're not connected yet - skip mail folder creation */
    if (!mx_is_imap(mutt_b2s(fpath)))
#endif
      if (stat(mutt_b2s(fpath), &sb) == -1 && errno == ENOENT)
      {
        snprintf(msg, sizeof(msg), _("%s does not exist. Create it?"), Maildir);
        if (mutt_yesorno(msg, MUTT_YES) == MUTT_YES)
        {
          if (mkdir(mutt_b2s(fpath), 0700) == -1 && errno != EEXIST)
            mutt_error( _("Can't create %s: %s."), Maildir, strerror(errno));
        }
      }
    mutt_buffer_pool_release(&fpath);
  }

  if (sendflags & SENDPOSTPONED)
  {
    if (!option(OPTNOCURSES))
      mutt_flushinp();
    mutt_send_message(SENDPOSTPONED, NULL, NULL, NULL, NULL);
  }
  else if (subject || msg || (sendflags & SENDMAILX) || draftFile ||
           includeFile || attach || optind < argc)
  {
    FILE *fin = NULL;
    FILE *fout = NULL;
    char *infile = NULL;
    char *bodytext = NULL;
    const char *bodyfile = NULL;
    int rv = 0;

    if (!option(OPTNOCURSES))
      mutt_flushinp();

    if (!msg)
      msg = mutt_new_header();
    if (!msg->env)
      msg->env = mutt_new_envelope();

    for (i = optind; i < argc; i++)
    {
      if (url_check_scheme(argv[i]) == U_MAILTO)
      {
        if (url_parse_mailto(msg->env, &bodytext, argv[i]) < 0)
        {
          if (!option(OPTNOCURSES))
          {
            mutt_endwin(NULL);
            set_option(OPTNOCURSES);
          }
          fputs(_("Failed to parse mailto: link\n"), stderr);
          goto cleanup_and_exit;
        }
      }
      else
        msg->env->to = rfc822_parse_adrlist(msg->env->to, argv[i]);
    }

    if (!draftFile && option(OPTAUTOEDIT) && !msg->env->to && !msg->env->cc)
    {
      if (!option(OPTNOCURSES))
      {
        mutt_endwin(NULL);
        set_option(OPTNOCURSES);
      }
      fputs(_("No recipients specified.\n"), stderr);
      goto cleanup_and_exit;
    }

    if (subject)
    {
      msg->env->subject = safe_strdup(subject);
      /* prevent header injection */
      mutt_filter_commandline_header_value(msg->env->subject);
    }

    if (draftFile)
    {
      infile = draftFile;
      includeFile = NULL;
    }
    else if (includeFile)
      infile = includeFile;
    else
      edit_infile = 0;

    if (infile || bodytext)
    {
      /* Prepare fin and expanded_infile. */
      if (infile)
      {
        if (mutt_strcmp("-", infile) == 0)
        {
          if (edit_infile)
          {
            fputs(_("Cannot use -E flag with stdin\n"), stderr);
            goto cleanup_and_exit;
          }
          fin = stdin;
        }
        else
        {
          expanded_infile = mutt_buffer_new();
          mutt_buffer_strcpy(expanded_infile, infile);
          mutt_buffer_expand_path(expanded_infile);
          if ((fin = fopen(mutt_b2s(expanded_infile), "r")) == NULL)
          {
            if (!option(OPTNOCURSES))
            {
              mutt_endwin(NULL);
              set_option(OPTNOCURSES);
            }
            perror(mutt_b2s(expanded_infile));
            goto cleanup_and_exit;
          }
        }
      }

      /* Copy input to a tempfile, and re-point fin to the tempfile.
       * Note: stdin is always copied to a tempfile, ensuring draftFile
       * can stat and get the correct st_size below.
       */
      if (!edit_infile)
      {
        tempfile = mutt_buffer_new();
        mutt_buffer_mktemp_draft(tempfile);

        if ((fout = safe_fopen(mutt_b2s(tempfile), "w")) == NULL)
        {
          if (!option(OPTNOCURSES))
          {
            mutt_endwin(NULL);
            set_option(OPTNOCURSES);
          }
          perror(mutt_b2s(tempfile));
          safe_fclose(&fin);
          goto cleanup_and_exit;
        }
        if (fin)
        {
          mutt_copy_stream(fin, fout);
          if (fin != stdin)
            safe_fclose(&fin);
        }
        else if (bodytext)
          fputs(bodytext, fout);
        safe_fclose(&fout);

        if ((fin = fopen(mutt_b2s(tempfile), "r")) == NULL)
        {
          if (!option(OPTNOCURSES))
          {
            mutt_endwin(NULL);
            set_option(OPTNOCURSES);
          }
          perror(mutt_b2s(tempfile));
          goto cleanup_and_exit;
        }
      }
      /* If editing the infile, keep it around afterwards so
       * it doesn't get unlinked, and we can rebuild the draftFile
       */
      else
        sendflags |= SENDNOFREEHEADER;

      /* Parse the draftFile into the full HEADER/BODY structure.
       * Set SENDDRAFTFILE so mutt_send_message doesn't overwrite
       * our msg->content.
       */
      if (draftFile)
      {
        HEADER *context_hdr = NULL;
        ENVELOPE *opts_env = msg->env;
        struct stat st;
        LIST *uh, **last_uhp;

        sendflags |= SENDDRAFTFILE;

        /* Set up a "context" header with just enough information so that
         * mutt_prepare_template() can parse the message in fin.
         */
        context_hdr = mutt_new_header();
        context_hdr->offset = 0;
        context_hdr->content = mutt_new_body();
        if (fstat(fileno(fin), &st))
        {
          perror(draftFile);
          goto cleanup_and_exit;
        }
        context_hdr->content->length = st.st_size;

        if (mutt_prepare_template(fin, NULL, msg, context_hdr, 0) < 0)
        {
          if (!option(OPTNOCURSES))
          {
            mutt_endwin(NULL);
            set_option(OPTNOCURSES);
          }
          /* L10N:
             Error when using -H command line argument, but reading the draft
             file fails for some reason.
          */
          fputs(_("Cannot parse draft file\n"), stderr);
          goto cleanup_and_exit;
        }


        /* Scan for mutt header to set OPTRESUMEDRAFTFILES */
        for (last_uhp = &msg->env->userhdrs, uh = *last_uhp;
             uh; uh = *last_uhp)
        {
          if (ascii_strncasecmp("X-Mutt-Resume-Draft:", uh->data, 20) == 0)
          {
            if (option(OPTRESUMEEDITEDDRAFTFILES))
              set_option(OPTRESUMEDRAFTFILES);

            *last_uhp = uh->next;
            uh->next = NULL;
            mutt_free_list(&uh);
          }
          else
            last_uhp = &uh->next;
        }

        rfc822_append(&msg->env->to, opts_env->to, 0);
        rfc822_append(&msg->env->cc, opts_env->cc, 0);
        rfc822_append(&msg->env->bcc, opts_env->bcc, 0);
        if (opts_env->subject)
          mutt_str_replace(&msg->env->subject, opts_env->subject);

        mutt_free_envelope(&opts_env);
        mutt_free_header(&context_hdr);
      }
      /* Editing the includeFile: pass it directly in.
       * Note that SENDNOFREEHEADER is set above so it isn't unlinked.
       */
      else if (edit_infile)
        bodyfile = mutt_b2s(expanded_infile);
      /* For bodytext and unedited includeFile: use the tempfile.
       */
      else
        bodyfile = mutt_b2s(tempfile);

      if (fin)
        safe_fclose(&fin);
    }

    FREE(&bodytext);

    if (attach)
    {
      LIST *t = attach;
      BODY *a = msg->content;

      while (a && a->next)
        a = a->next;

      while (t)
      {
        if (a)
        {
          a->next = mutt_make_file_attach(t->data);
          a = a->next;
        }
        else
          msg->content = a = mutt_make_file_attach(t->data);
        if (!a)
        {
          if (!option(OPTNOCURSES))
          {
            mutt_endwin(NULL);
            set_option(OPTNOCURSES);
          }
          fprintf(stderr, _("%s: unable to attach file.\n"), NONULL(t->data));
          mutt_free_list(&attach);
          goto cleanup_and_exit;
        }
        t = t->next;
      }
      mutt_free_list(&attach);
    }

    rv = mutt_send_message(sendflags, msg, bodyfile, NULL, NULL);

    if (edit_infile)
    {
      if (includeFile)
        msg->content->unlink = 0;
      else if (draftFile)
      {
        if (truncate(mutt_b2s(expanded_infile), 0) == -1)
        {
          if (!option(OPTNOCURSES))
          {
            mutt_endwin(NULL);
            set_option(OPTNOCURSES);
          }
          perror(mutt_b2s(expanded_infile));
          goto cleanup_and_exit;
        }
        if ((fout = safe_fopen(mutt_b2s(expanded_infile), "a")) == NULL)
        {
          if (!option(OPTNOCURSES))
          {
            mutt_endwin(NULL);
            set_option(OPTNOCURSES);
          }
          perror(mutt_b2s(expanded_infile));
          goto cleanup_and_exit;
        }

        /* If the message was sent or postponed, these will already
         * have been done.
         */
        if (rv < 0)
        {
          if (msg->content->next)
            msg->content = mutt_make_multipart_mixed(msg->content);
          mutt_encode_descriptions(msg->content, 1);
          mutt_prepare_envelope(msg->env, 0);
          mutt_env_to_intl(msg->env, NULL, NULL);
        }

        mutt_write_rfc822_header(fout, msg->env, msg->content, NULL,
                                 MUTT_WRITE_HEADER_POSTPONE, 0,
                                 option(OPTCRYPTPROTHDRSREAD) &&
                                 mutt_should_hide_protected_subject(msg));
        if (option(OPTRESUMEEDITEDDRAFTFILES))
          fprintf(fout, "X-Mutt-Resume-Draft: 1\n");
        fputc('\n', fout);
        if ((mutt_write_mime_body(msg->content, fout) == -1))
        {
          safe_fclose(&fout);
          goto cleanup_and_exit;
        }
        safe_fclose(&fout);
      }

      mutt_free_header(&msg);
    }

    /* !edit_infile && draftFile will leave the tempfile around */
    if (tempfile)
      unlink(mutt_b2s(tempfile));

    if (rv)
      goto cleanup_and_exit;
  }
  /* This guards against invoking `mutt < /dev/null` and accidentally
   * sending an email due to a my_hdr or other setting.
   */
  else if (sendflags & SENDBATCH)
  {
    fputs(_("No recipients specified.\n"), stderr);
    goto cleanup_and_exit;
  }
  else
  {
    if (!folder)
      folder = mutt_buffer_new();

    if (flags & MUTT_BUFFY)
    {
#ifdef USE_IMAP
      int passive = option(OPTIMAPPASSIVE);
      if (passive)
        unset_option(OPTIMAPPASSIVE);
#endif
      if (!mutt_buffy_check(0))
      {
        exit_endwin_msg = _("No mailbox with new mail.");
        goto cleanup_and_exit;
      }
      mutt_buffer_clear(folder);
      mutt_buffer_buffy(folder);
#ifdef USE_IMAP
      if (passive)
        set_option(OPTIMAPPASSIVE);
#endif
    }
    else if (flags & MUTT_SELECT)
    {
      if (!Incoming)
      {
        exit_endwin_msg = _("No incoming mailboxes defined.");
        goto cleanup_and_exit;
      }
      mutt_buffer_clear(folder);
      mutt_buffer_select_file(folder, MUTT_SEL_MAILBOX | MUTT_SEL_BUFFY);
      if (!mutt_buffer_len(folder))
      {
        exit_code = 0;
        goto cleanup_and_exit;
      }
    }

    if (!mutt_buffer_len(folder))
      mutt_buffer_strcpy(folder, NONULL(Spoolfile));
    mutt_buffer_expand_path(folder);

    mutt_str_replace(&CurrentFolder, mutt_b2s(folder));
    mutt_str_replace(&LastFolder, mutt_b2s(folder));

    if (flags & MUTT_IGNORE)
    {
      /* check to see if there are any messages in the folder */
      switch (mx_check_empty(mutt_b2s(folder)))
      {
        case -1:
          exit_endwin_msg = strerror(errno);
          goto cleanup_and_exit;
        case 1:
          exit_endwin_msg = _("Mailbox is empty.");
          goto cleanup_and_exit;
      }
    }

    mutt_folder_hook(mutt_b2s(folder));

    Context = mx_open_mailbox(mutt_b2s(folder),
                              ((flags & MUTT_RO) || option(OPTREADONLY)) ? MUTT_READONLY : 0,
                              NULL);
    mutt_buffer_free(&folder);

    if (Context || !explicit_folder)
    {
#ifdef USE_SIDEBAR
      mutt_sb_set_open_buffy();
#endif
      mutt_index_menu();
      if (Context)
        FREE(&Context);
    }

    exit_endwin_msg = Errorbuf;
  }

  exit_code = 0;

cleanup_and_exit:
  mutt_buffer_free(&folder);
  mutt_buffer_free(&expanded_infile);
  mutt_buffer_free(&tempfile);
#ifdef USE_IMAP
  imap_logout_all();
#endif
#ifdef USE_SASL_CYRUS
  mutt_sasl_done();
#endif
#ifdef USE_SASL_GNU
  mutt_gsasl_done();
#endif
#ifdef USE_AUTOCRYPT
  mutt_autocrypt_cleanup();
#endif
  mutt_browser_cleanup();
  mutt_commands_cleanup();
  crypt_cleanup();
  mutt_signal_cleanup();
  mutt_free_opts();
  mutt_free_windows();
  mutt_buffer_pool_free();
  if (!option(OPTNOCURSES))
    mutt_endwin(exit_endwin_msg);
  exit(exit_code);
}
