smtp.c File Reference

Send email to an SMTP server. More...

#include "config.h"
#include <arpa/inet.h>
#include <netdb.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <unistd.h>
#include "mutt/lib.h"
#include "address/lib.h"
#include "config/lib.h"
#include "email/lib.h"
#include "core/lib.h"
#include "conn/lib.h"
#include "smtp.h"
#include "progress/lib.h"
#include "question/lib.h"
#include "globals.h"
#include "mutt_socket.h"
#include "muttlib.h"
#include "sendlib.h"

Include dependency graph for smtp.c:

Go to the source code of this file.

Data Structures
struct	SmtpAccountData
	Server connection data. More...
struct	SmtpAuth
	SMTP authentication multiplexor. More...

Macros
#define	smtp_success(x)
	Check if SMTP response code indicates success (2xx codes)
#define	SMTP_READY   334
	SMTP server ready for authentication data.
#define	SMTP_CONTINUE   354
	SMTP server ready to accept message data.
#define	SMTP_ERR_READ   -2
	Error reading from server.
#define	SMTP_ERR_WRITE   -3
	Error writing to server.
#define	SMTP_ERR_CODE   -4
	Invalid server response code.
#define	SMTP_PORT   25
	Default SMTP port.
#define	SMTPS_PORT   465
	Default SMTPS (SMTP over SSL) port.
#define	SMTP_AUTH_SUCCESS   0
	Authentication completed successfully.
#define	SMTP_AUTH_UNAVAIL   1
	Authentication method unavailable.
#define	SMTP_AUTH_FAIL   -1
	Authentication failed.
#define	SMTP_CAP_ALL   ((1U << 5) - 1)
	All SMTP capability flags.

Typedefs
typedef uint8_t	SmtpCapFlags

Enumerations
enum	SmtpCapFlag {   SMTP_CAP_NONE = 0 , SMTP_CAP_STARTTLS = 1U << 0 , SMTP_CAP_AUTH = 1U << 1 , SMTP_CAP_DSN = 1U << 2 ,   SMTP_CAP_EIGHTBITMIME = 1U << 3 , SMTP_CAP_SMTPUTF8 = 1U << 4 }
	SMTP server capabilities. More...

Functions
static bool	valid_smtp_code (char *buf, int *n)
	Is the is a valid SMTP return code?
static int	smtp_get_resp (struct SmtpAccountData *adata)
	Read a command response from the SMTP server.
static int	smtp_rcpt_to (struct SmtpAccountData *adata, const struct AddressList *al)
	Set the recipient to an Address.
static int	smtp_data (struct SmtpAccountData *adata, const char *msgfile)
	Send data to an SMTP server.
static const char *	smtp_get_field (enum ConnAccountField field, void *gf_data)
	Get connection login credentials - Implements ConnAccount::get_field() -.
static int	smtp_fill_account (struct SmtpAccountData *adata, struct ConnAccount *cac)
	Create ConnAccount object from SMTP Url.
static int	smtp_helo (struct SmtpAccountData *adata, bool esmtp)
	Say hello to an SMTP Server.
static int	smtp_auth_oauth_xoauth2 (struct SmtpAccountData *adata, const char *method, bool xoauth2)
	Authenticate an SMTP connection using OAUTHBEARER/XOAUTH2.
static int	smtp_auth_oauth (struct SmtpAccountData *adata, const char *method)
	Authenticate an SMTP connection using OAUTHBEARER - Implements SmtpAuth::authenticate() -.
static int	smtp_auth_xoauth2 (struct SmtpAccountData *adata, const char *method)
	Authenticate an SMTP connection using XOAUTH2 - Implements SmtpAuth::authenticate() -.
static int	smtp_auth_plain (struct SmtpAccountData *adata, const char *method)
	Authenticate using plain text - Implements SmtpAuth::authenticate() -.
static int	smtp_auth_login (struct SmtpAccountData *adata, const char *method)
	Authenticate using plain text - Implements SmtpAuth::authenticate() -.
bool	smtp_auth_is_valid (const char *authenticator)
	Check if string is a valid smtp authentication method.
static int	smtp_authenticate (struct SmtpAccountData *adata)
	Authenticate to an SMTP server.
static int	smtp_open (struct SmtpAccountData *adata, bool esmtp)
	Open an SMTP Connection.
int	mutt_smtp_send (const struct AddressList *from, const struct AddressList *to, const struct AddressList *cc, const struct AddressList *bcc, const char *msgfile, bool eightbit, struct ConfigSubset *sub)
	Send a message using SMTP.

Variables
static const struct SmtpAuth	SmtpAuthenticators []
	Accepted authentication methods.

Detailed Description

Send email to an SMTP server.

Authors

• Richard Russon
• Pietro Cerutti
• Yousef Akbar
• Ryan Kavanagh
• Alejandro Colomar
• Anna Figueiredo Gomes
• Rayford Shireman

Copyright

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, see http://www.gnu.org/licenses/.

Definition in file smtp.c.

Macro Definition Documentation

smtp_success

#define smtp_success

(

x

)

Value:

(((x) / 100) == 2)

Check if SMTP response code indicates success (2xx codes)

Definition at line 65 of file smtp.c.

SMTP_READY

#define SMTP_READY   334

SMTP server ready for authentication data.

Definition at line 66 of file smtp.c.

SMTP_CONTINUE

#define SMTP_CONTINUE   354

SMTP server ready to accept message data.

Definition at line 67 of file smtp.c.

SMTP_ERR_READ

#define SMTP_ERR_READ   -2

Error reading from server.

Definition at line 69 of file smtp.c.

SMTP_ERR_WRITE

#define SMTP_ERR_WRITE   -3

Error writing to server.

Definition at line 70 of file smtp.c.

SMTP_ERR_CODE

#define SMTP_ERR_CODE   -4

Invalid server response code.

Definition at line 71 of file smtp.c.

SMTP_PORT

#define SMTP_PORT   25

Default SMTP port.

Definition at line 73 of file smtp.c.

SMTPS_PORT

#define SMTPS_PORT   465

Default SMTPS (SMTP over SSL) port.

Definition at line 74 of file smtp.c.

SMTP_AUTH_SUCCESS

#define SMTP_AUTH_SUCCESS   0

Authentication completed successfully.

Definition at line 76 of file smtp.c.

SMTP_AUTH_UNAVAIL

#define SMTP_AUTH_UNAVAIL   1

Authentication method unavailable.

Definition at line 77 of file smtp.c.

SMTP_AUTH_FAIL

#define SMTP_AUTH_FAIL   -1

Authentication failed.

Definition at line 78 of file smtp.c.

SMTP_CAP_ALL

#define SMTP_CAP_ALL   ((1U << 5) - 1)

All SMTP capability flags.

Definition at line 96 of file smtp.c.

Typedef Documentation

SmtpCapFlags

typedef uint8_t SmtpCapFlags

Definition at line 94 of file smtp.c.

Enumeration Type Documentation

SmtpCapFlag

enum SmtpCapFlag

SMTP server capabilities.

Enumerator
SMTP_CAP_NONE	No flags are set.
SMTP_CAP_STARTTLS	Server supports STARTTLS command.
SMTP_CAP_AUTH	Server supports AUTH command.
SMTP_CAP_DSN	Server supports Delivery Status Notification.
SMTP_CAP_EIGHTBITMIME	Server supports 8-bit MIME content.
SMTP_CAP_SMTPUTF8	Server accepts UTF-8 strings.

Definition at line 83 of file smtp.c.

{
  // clang-format off
  SMTP_CAP_NONE         =       0,  
  SMTP_CAP_STARTTLS     = 1U << 0,  
  SMTP_CAP_AUTH         = 1U << 1,  
  SMTP_CAP_DSN          = 1U << 2,  
  SMTP_CAP_EIGHTBITMIME = 1U << 3,  
  SMTP_CAP_SMTPUTF8     = 1U << 4,  
  // clang-format on
};

Function Documentation

valid_smtp_code()

static bool valid_smtp_code ( char * buf, int * n )

static

Is the is a valid SMTP return code?

Parameters

[in]	buf	String to check
[out]	n	Numeric value of code

Return values

true	Valid number

Definition at line 135 of file smtp.c.

{
  return (mutt_str_atoi(buf, n) - buf) <= 3;
}

Here is the call graph for this function:

Here is the caller graph for this function:

smtp_get_resp()

static int smtp_get_resp ( struct SmtpAccountData * adata )

static

Read a command response from the SMTP server.

Parameters

adata

SMTP Account data

Return values

0	Success (2xx code) or continue (354 code)
-1	Write error, or any other response code

Definition at line 146 of file smtp.c.

{
  int n = 0;
  char buf[1024] = { 0 };
 
  do
  {
    n = mutt_socket_readln(buf, sizeof(buf), adata->conn);
    if (n < 4)
    {
      /* read error, or no response code */
      return SMTP_ERR_READ;
    }
    const char *s = buf + 4; /* Skip the response code and the space/dash */
    size_t plen;
 
    if (mutt_istr_startswith(s, "8BITMIME"))
    {
      adata->capabilities |= SMTP_CAP_EIGHTBITMIME;
    }
    else if ((plen = mutt_istr_startswith(s, "AUTH ")))
    {
      adata->capabilities |= SMTP_CAP_AUTH;
      FREE(&adata->auth_mechs);
      adata->auth_mechs = mutt_str_dup(s + plen);
    }
    else if (mutt_istr_startswith(s, "DSN"))
    {
      adata->capabilities |= SMTP_CAP_DSN;
    }
    else if (mutt_istr_startswith(s, "STARTTLS"))
    {
      adata->capabilities |= SMTP_CAP_STARTTLS;
    }
    else if (mutt_istr_startswith(s, "SMTPUTF8"))
    {
      adata->capabilities |= SMTP_CAP_SMTPUTF8;
    }
 
    if (!valid_smtp_code(buf, &n))
      return SMTP_ERR_CODE;
 
  } while (buf[3] == '-');
 
  if (smtp_success(n) || (n == SMTP_CONTINUE))
    return 0;
 
  mutt_error(_("SMTP session failed: %s"), buf);
  return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

smtp_rcpt_to()

static int smtp_rcpt_to ( struct SmtpAccountData * adata, const struct AddressList * al )

static

Set the recipient to an Address.

Parameters

adata	SMTP Account data
al	AddressList to use

Return values

0	Success
<0	Error, e.g. SMTP_ERR_WRITE

Definition at line 204 of file smtp.c.

{
  if (!al)
    return 0;
 
  const char *const c_dsn_notify = cs_subset_string(adata->sub, "dsn_notify");
 
  struct Address *a = NULL;
  TAILQ_FOREACH(a, al, entries)
  {
    /* weed out group mailboxes, since those are for display only */
    if (!a->mailbox || a->group)
    {
      continue;
    }
    char buf[1024] = { 0 };
    if ((adata->capabilities & SMTP_CAP_DSN) && c_dsn_notify)
    {
      snprintf(buf, sizeof(buf), "RCPT TO:<%s> NOTIFY=%s\r\n",
               buf_string(a->mailbox), c_dsn_notify);
    }
    else
    {
      snprintf(buf, sizeof(buf), "RCPT TO:<%s>\r\n", buf_string(a->mailbox));
    }
    if (mutt_socket_send(adata->conn, buf) == -1)
      return SMTP_ERR_WRITE;
    int rc = smtp_get_resp(adata);
    if (rc != 0)
    {
      mutt_sleep(2);
      mutt_error(_("SMTP session failed: cannot add recipient <%s>"),
                 buf_string(a->mailbox));
      return rc;
    }
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

smtp_data()

static int smtp_data ( struct SmtpAccountData * adata, const char * msgfile )

static

Send data to an SMTP server.

Parameters

adata	SMTP Account data
msgfile	Filename containing data

Return values

0	Success
<0	Error, e.g. SMTP_ERR_WRITE

Definition at line 251 of file smtp.c.

{
  char buf[1024] = { 0 };
  struct Progress *progress = NULL;
  int rc = SMTP_ERR_WRITE;
  int term = 0;
  size_t buflen = 0;
 
  FILE *fp = mutt_file_fopen(msgfile, "r");
  if (!fp)
  {
    mutt_error(_("SMTP session failed: unable to open %s"), msgfile);
    return -1;
  }
  const long size = mutt_file_get_size_fp(fp);
  if (size == 0)
  {
    mutt_file_fclose(&fp);
    return -1;
  }
  unlink(msgfile);
  progress = progress_new(MUTT_PROGRESS_NET, size);
  progress_set_message(progress, _("Sending message..."));
 
  snprintf(buf, sizeof(buf), "DATA\r\n");
  if (mutt_socket_send(adata->conn, buf) == -1)
  {
    mutt_file_fclose(&fp);
    goto done;
  }
  rc = smtp_get_resp(adata);
  if (rc != 0)
  {
    mutt_file_fclose(&fp);
    goto done;
  }
 
  rc = SMTP_ERR_WRITE;
  while (fgets(buf, sizeof(buf) - 1, fp))
  {
    buflen = mutt_str_len(buf);
    term = buflen && buf[buflen - 1] == '\n';
    if (term && ((buflen == 1) || (buf[buflen - 2] != '\r')))
      snprintf(buf + buflen - 1, sizeof(buf) - buflen + 1, "\r\n");
    if (buf[0] == '.')
    {
      if (mutt_socket_send_d(adata->conn, ".", MUTT_SOCK_LOG_FULL) == -1)
      {
        mutt_file_fclose(&fp);
        goto done;
      }
    }
    if (mutt_socket_send_d(adata->conn, buf, MUTT_SOCK_LOG_FULL) == -1)
    {
      mutt_file_fclose(&fp);
      goto done;
    }
    progress_update(progress, MAX(0, ftell(fp)), -1);
  }
  if (!term && buflen &&
      (mutt_socket_send_d(adata->conn, "\r\n", MUTT_SOCK_LOG_FULL) == -1))
  {
    mutt_file_fclose(&fp);
    goto done;
  }
  mutt_file_fclose(&fp);
 
  /* terminate the message body */
  if (mutt_socket_send(adata->conn, ".\r\n") == -1)
    goto done;
 
  rc = smtp_get_resp(adata);
 
done:
  progress_free(&progress);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

smtp_fill_account()

static int smtp_fill_account ( struct SmtpAccountData * adata, struct ConnAccount * cac )

static

Create ConnAccount object from SMTP Url.

Parameters

adata	SMTP Account data
cac	ConnAccount to populate

Return values

0	Success
-1	Error

Definition at line 369 of file smtp.c.

{
  cac->flags = 0;
  cac->port = 0;
  cac->type = MUTT_ACCT_TYPE_SMTP;
  cac->service = "smtp";
  cac->get_field = smtp_get_field;
  cac->gf_data = adata;
 
  const char *const c_smtp_url = cs_subset_string(adata->sub, "smtp_url");
 
  struct Url *url = url_parse(c_smtp_url);
  if (!url || ((url->scheme != U_SMTP) && (url->scheme != U_SMTPS)) ||
      !url->host || (account_from_url(cac, url) < 0))
  {
    url_free(&url);
    mutt_error(_("Invalid SMTP URL: %s"), c_smtp_url);
    return -1;
  }
 
  if (url->scheme == U_SMTPS)
    cac->flags |= MUTT_ACCT_SSL;
 
  if (cac->port == 0)
  {
    if (cac->flags & MUTT_ACCT_SSL)
    {
      cac->port = SMTPS_PORT;
    }
    else
    {
      static unsigned short SmtpPort = 0;
      if (SmtpPort == 0)
      {
        struct servent *service = getservbyname("smtp", "tcp");
        if (service)
          SmtpPort = ntohs(service->s_port);
        else
          SmtpPort = SMTP_PORT;
        mutt_debug(LL_DEBUG3, "Using default SMTP port %d\n", SmtpPort);
      }
      cac->port = SmtpPort;
    }
  }
 
  url_free(&url);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

smtp_helo()

static int smtp_helo ( struct SmtpAccountData * adata, bool esmtp )

static

Say hello to an SMTP Server.

Parameters

adata	SMTP Account data
esmtp	If true, use ESMTP

Return values

0	Success
<0	Error, e.g. SMTP_ERR_WRITE

Definition at line 425 of file smtp.c.

{
  adata->capabilities = SMTP_CAP_NONE;
 
  if (!esmtp)
  {
    /* if TLS or AUTH are requested, use EHLO */
    if (adata->conn->account.flags & MUTT_ACCT_USER)
      esmtp = true;
#ifdef USE_SSL
    const bool c_ssl_force_tls = cs_subset_bool(adata->sub, "ssl_force_tls");
    const enum QuadOption c_ssl_starttls = cs_subset_quad(adata->sub, "ssl_starttls");
 
    if (c_ssl_force_tls || (c_ssl_starttls != MUTT_NO))
      esmtp = true;
#endif
  }
 
  char buf[1024] = { 0 };
  snprintf(buf, sizeof(buf), "%s %s\r\n", esmtp ? "EHLO" : "HELO", adata->fqdn);
  /* XXX there should probably be a wrapper in mutt_socket.c that
   * repeatedly calls adata->conn->write until all data is sent.  This
   * currently doesn't check for a short write.  */
  if (mutt_socket_send(adata->conn, buf) == -1)
    return SMTP_ERR_WRITE;
  return smtp_get_resp(adata);
}

Here is the call graph for this function:

Here is the caller graph for this function:

smtp_auth_oauth_xoauth2()

static int smtp_auth_oauth_xoauth2 ( struct SmtpAccountData * adata, const char * method, bool xoauth2 )

static

Authenticate an SMTP connection using OAUTHBEARER/XOAUTH2.

Parameters

adata	SMTP Account data
method	Authentication method
xoauth2	Use XOAUTH2 token (if true), OAUTHBEARER token otherwise

Return values

num	Result, e.g. SMTP_AUTH_SUCCESS

Definition at line 769 of file smtp.c.

{
  /* If they did not explicitly request or configure oauth then fail quietly */
  const char *const c_smtp_oauth_refresh_command = cs_subset_string(NeoMutt->sub, "smtp_oauth_refresh_command");
  if (!method && !c_smtp_oauth_refresh_command)
    return SMTP_AUTH_UNAVAIL;
 
  const char *authtype = xoauth2 ? "XOAUTH2" : "OAUTHBEARER";
 
  // L10N: (%s) is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_message(_("Authenticating (%s)..."), authtype);
 
  /* We get the access token from the smtp_oauth_refresh_command */
  char *oauthbearer = mutt_account_getoauthbearer(&adata->conn->account, xoauth2);
  if (!oauthbearer)
    return SMTP_AUTH_FAIL;
 
  char *ibuf = NULL;
  mutt_str_asprintf(&ibuf, "AUTH %s %s\r\n", authtype, oauthbearer);
 
  int rc = mutt_socket_send(adata->conn, ibuf);
  FREE(&oauthbearer);
  FREE(&ibuf);
 
  if (rc == -1)
    return SMTP_AUTH_FAIL;
  if (smtp_get_resp(adata) != 0)
    return SMTP_AUTH_FAIL;
 
  return SMTP_AUTH_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

smtp_auth_is_valid()

bool smtp_auth_is_valid

(

const char *

authenticator

)

Check if string is a valid smtp authentication method.

Parameters

authenticator

Authenticator string to check

Return values

true	Argument is a valid auth method

Validate whether an input string is an accepted smtp authentication method as defined by SmtpAuthenticators.

Definition at line 963 of file smtp.c.

{
  for (size_t i = 0; i < countof(SmtpAuthenticators); i++)
  {
    const struct SmtpAuth *auth = &SmtpAuthenticators[i];
    if (auth->method && mutt_istr_equal(auth->method, authenticator))
      return true;
  }
 
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

smtp_authenticate()

static int smtp_authenticate ( struct SmtpAccountData * adata )

static

Authenticate to an SMTP server.

Parameters

adata

SMTP Account data

Return values

0	Success
<0	Error, e.g. SMTP_AUTH_FAIL

Definition at line 981 of file smtp.c.

{
  int r = SMTP_AUTH_UNAVAIL;
 
  const struct Slist *c_smtp_authenticators = cs_subset_slist(adata->sub, "smtp_authenticators");
  if (c_smtp_authenticators && (c_smtp_authenticators->count > 0))
  {
    mutt_debug(LL_DEBUG2, "Trying user-defined smtp_authenticators\n");
 
    /* Try user-specified list of authentication methods */
    struct ListNode *np = NULL;
    STAILQ_FOREACH(np, &c_smtp_authenticators->head, entries)
    {
      mutt_debug(LL_DEBUG2, "Trying method %s\n", np->data);
 
      for (size_t i = 0; i < countof(SmtpAuthenticators); i++)
      {
        const struct SmtpAuth *auth = &SmtpAuthenticators[i];
        if (!auth->method || mutt_istr_equal(auth->method, np->data))
        {
          r = auth->authenticate(adata, np->data);
          if (r == SMTP_AUTH_SUCCESS)
            return r;
        }
      }
    }
  }
  else
  {
    /* Fall back to default: any authenticator */
#if defined(USE_SASL_CYRUS)
    mutt_debug(LL_DEBUG2, "Falling back to smtp_auth_sasl, if using sasl\n");
    r = smtp_auth_sasl(adata, adata->auth_mechs);
#elif defined(USE_SASL_GNU)
    mutt_debug(LL_DEBUG2, "Falling back to smtp_auth_gsasl, if using gsasl\n");
    r = smtp_auth_gsasl(adata, adata->auth_mechs);
#else
    mutt_debug(LL_DEBUG2, "Falling back to using any authenticator available\n");
    /* Try all available authentication methods */
    for (size_t i = 0; i < countof(SmtpAuthenticators); i++)
    {
      const struct SmtpAuth *auth = &SmtpAuthenticators[i];
      mutt_debug(LL_DEBUG2, "Trying method %s\n", auth->method ? auth->method : "<variable>");
      r = auth->authenticate(adata, auth->method);
      if (r == SMTP_AUTH_SUCCESS)
        return r;
    }
#endif
  }
 
  if (r != SMTP_AUTH_SUCCESS)
    mutt_account_unsetpass(&adata->conn->account);
 
  if (r == SMTP_AUTH_FAIL)
  {
    // L10N: %s is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
    mutt_error(_("%s authentication failed"), "SASL");
  }
  else if (r == SMTP_AUTH_UNAVAIL)
  {
    mutt_error(_("No authenticators available"));
  }
 
  return (r == SMTP_AUTH_SUCCESS) ? 0 : -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

smtp_open()

static int smtp_open ( struct SmtpAccountData * adata, bool esmtp )

static

Open an SMTP Connection.

Parameters

adata	SMTP Account data
esmtp	If true, use ESMTP

Return values

0	Success
-1	Error

Definition at line 1054 of file smtp.c.

{
  int rc;
 
  if (mutt_socket_open(adata->conn))
    return -1;
 
  const bool force_auth = cs_subset_string(adata->sub, "smtp_user");
  esmtp |= force_auth;
 
  /* get greeting string */
  rc = smtp_get_resp(adata);
  if (rc != 0)
    return rc;
 
  rc = smtp_helo(adata, esmtp);
  if (rc != 0)
    return rc;
 
#ifdef USE_SSL
  const bool c_ssl_force_tls = cs_subset_bool(adata->sub, "ssl_force_tls");
  enum QuadOption ans = MUTT_NO;
  if (adata->conn->ssf != 0)
    ans = MUTT_NO;
  else if (c_ssl_force_tls)
    ans = MUTT_YES;
  else if ((adata->capabilities & SMTP_CAP_STARTTLS) &&
           ((ans = query_quadoption(_("Secure connection with TLS?"),
                                    adata->sub, "ssl_starttls")) == MUTT_ABORT))
  {
    return -1;
  }
 
  if (ans == MUTT_YES)
  {
    if (mutt_socket_send(adata->conn, "STARTTLS\r\n") < 0)
      return SMTP_ERR_WRITE;
    rc = smtp_get_resp(adata);
    // Clear any data after the STARTTLS acknowledgement
    mutt_socket_empty(adata->conn);
    if (rc != 0)
      return rc;
 
    if (mutt_ssl_starttls(adata->conn) != 0)
    {
      mutt_error(_("Could not negotiate TLS connection"));
      return -1;
    }
 
    /* re-EHLO to get authentication mechanisms */
    rc = smtp_helo(adata, esmtp);
    if (rc != 0)
      return rc;
  }
#endif
 
  if (force_auth || adata->conn->account.flags & MUTT_ACCT_USER)
  {
    if (!(adata->capabilities & SMTP_CAP_AUTH))
    {
      mutt_error(_("SMTP server does not support authentication"));
      return -1;
    }
 
    return smtp_authenticate(adata);
  }
 
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mutt_smtp_send()

int mutt_smtp_send	(	const struct AddressList *	from,
		const struct AddressList *	to,
		const struct AddressList *	cc,
		const struct AddressList *	bcc,
		const char *	msgfile,
		bool	eightbit,
		struct ConfigSubset *	sub )

Send a message using SMTP.

Parameters

from	From Address
to	To Address
cc	Cc Address
bcc	Bcc Address
msgfile	Message to send to the server
eightbit	If true, try for an 8-bit friendly connection
sub	Config Subset

Return values

0	Success
-1	Error

Definition at line 1136 of file smtp.c.

{
  struct SmtpAccountData adata = { 0 };
  struct ConnAccount cac = { { 0 } };
  const char *envfrom = NULL;
  int rc = -1;
 
  adata.sub = sub;
  adata.fqdn = mutt_fqdn(false, adata.sub);
  if (!adata.fqdn)
    adata.fqdn = NONULL(ShortHostname);
 
  const struct Address *c_envelope_from_address = cs_subset_address(adata.sub, "envelope_from_address");
 
  if (smtp_fill_account(&adata, &cac) < 0)
    return rc;
 
  adata.conn = mutt_conn_find(&cac);
  if (!adata.conn)
    return -1;
 
  /* it might be better to synthesize an envelope from from user and host
   * but this condition is most likely arrived at accidentally */
  if (c_envelope_from_address)
  {
    envfrom = buf_string(c_envelope_from_address->mailbox);
  }
  else if (from && !TAILQ_EMPTY(from))
  {
    envfrom = buf_string(TAILQ_FIRST(from)->mailbox);
  }
  else
  {
    mutt_error(_("No from address given"));
    mutt_socket_close(adata.conn);
    return -1;
  }
 
  const char *const c_dsn_return = cs_subset_string(adata.sub, "dsn_return");
 
  struct Buffer *buf = buf_pool_get();
  do
  {
    /* send our greeting */
    rc = smtp_open(&adata, eightbit);
    if (rc != 0)
      break;
    FREE(&adata.auth_mechs);
 
    /* send the sender's address */
    buf_printf(buf, "MAIL FROM:<%s>", envfrom);
    if (eightbit && (adata.capabilities & SMTP_CAP_EIGHTBITMIME))
      buf_addstr(buf, " BODY=8BITMIME");
 
    if (c_dsn_return && (adata.capabilities & SMTP_CAP_DSN))
      buf_add_printf(buf, " RET=%s", c_dsn_return);
 
    if ((adata.capabilities & SMTP_CAP_SMTPUTF8) &&
        (mutt_addr_uses_unicode(envfrom) || mutt_addrlist_uses_unicode(to) ||
         mutt_addrlist_uses_unicode(cc) || mutt_addrlist_uses_unicode(bcc)))
    {
      buf_addstr(buf, " SMTPUTF8");
    }
    buf_addstr(buf, "\r\n");
    if (mutt_socket_send(adata.conn, buf_string(buf)) == -1)
    {
      rc = SMTP_ERR_WRITE;
      break;
    }
    rc = smtp_get_resp(&adata);
    if (rc != 0)
      break;
 
    /* send the recipient list */
    if ((rc = smtp_rcpt_to(&adata, to)) || (rc = smtp_rcpt_to(&adata, cc)) ||
        (rc = smtp_rcpt_to(&adata, bcc)))
    {
      break;
    }
 
    /* send the message data */
    rc = smtp_data(&adata, msgfile);
    if (rc != 0)
      break;
 
    mutt_socket_send(adata.conn, "QUIT\r\n");
 
    rc = 0;
  } while (false);
 
  mutt_socket_close(adata.conn);
  FREE(&adata.conn);
  FREE(&adata.auth_mechs);
 
  if (rc == SMTP_ERR_READ)
    mutt_error(_("SMTP session failed: read error"));
  else if (rc == SMTP_ERR_WRITE)
    mutt_error(_("SMTP session failed: write error"));
  else if (rc == SMTP_ERR_CODE)
    mutt_error(_("Invalid server response"));
 
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

SmtpAuthenticators

const struct SmtpAuth SmtpAuthenticators[]

static

Initial value:

= {
  
  { smtp_auth_oauth, "oauthbearer" },
  { smtp_auth_xoauth2, "xoauth2" },
  { smtp_auth_plain, "plain" },
  { smtp_auth_login, "login" },
 
 
 
 
 
 
  
}

Accepted authentication methods.

Definition at line 940 of file smtp.c.

                                                    {
  // clang-format off
  { smtp_auth_oauth, "oauthbearer" },
  { smtp_auth_xoauth2, "xoauth2" },
  { smtp_auth_plain, "plain" },
  { smtp_auth_login, "login" },
#ifdef USE_SASL_CYRUS
  { smtp_auth_sasl, NULL },
#endif
#ifdef USE_SASL_GNU
  { smtp_auth_gsasl, NULL },
#endif
  // clang-format on
};