NeoMutt  2024-12-12-19-ge4b57e
Teaching an old dog new tricks
DOXYGEN
All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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 "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)   (((x) / 100) == 2)
 
#define SMTP_READY   334
 
#define SMTP_CONTINUE   354
 
#define SMTP_ERR_READ   -2
 
#define SMTP_ERR_WRITE   -3
 
#define SMTP_ERR_CODE   -4
 
#define SMTP_PORT   25
 
#define SMTPS_PORT   465
 
#define SMTP_AUTH_SUCCESS   0
 
#define SMTP_AUTH_UNAVAIL   1
 
#define SMTP_AUTH_FAIL   -1
 
#define SMTP_CAP_NO_FLAGS   0
 No flags are set.
 
#define SMTP_CAP_STARTTLS   (1 << 0)
 Server supports STARTTLS command.
 
#define SMTP_CAP_AUTH   (1 << 1)
 Server supports AUTH command.
 
#define SMTP_CAP_DSN   (1 << 2)
 Server supports Delivery Status Notification.
 
#define SMTP_CAP_EIGHTBITMIME   (1 << 3)
 Server supports 8-bit MIME content.
 
#define SMTP_CAP_SMTPUTF8   (1 << 4)
 Server accepts UTF-8 strings.
 
#define SMTP_CAP_ALL   ((1 << 5) - 1)
 

Typedefs

typedef uint8_t SmtpCapFlags
 SMTP server capabilities.
 

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

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)    (((x) / 100) == 2)

Definition at line 63 of file smtp.c.

◆ SMTP_READY

#define SMTP_READY   334

Definition at line 64 of file smtp.c.

◆ SMTP_CONTINUE

#define SMTP_CONTINUE   354

Definition at line 65 of file smtp.c.

◆ SMTP_ERR_READ

#define SMTP_ERR_READ   -2

Definition at line 67 of file smtp.c.

◆ SMTP_ERR_WRITE

#define SMTP_ERR_WRITE   -3

Definition at line 68 of file smtp.c.

◆ SMTP_ERR_CODE

#define SMTP_ERR_CODE   -4

Definition at line 69 of file smtp.c.

◆ SMTP_PORT

#define SMTP_PORT   25

Definition at line 71 of file smtp.c.

◆ SMTPS_PORT

#define SMTPS_PORT   465

Definition at line 72 of file smtp.c.

◆ SMTP_AUTH_SUCCESS

#define SMTP_AUTH_SUCCESS   0

Definition at line 74 of file smtp.c.

◆ SMTP_AUTH_UNAVAIL

#define SMTP_AUTH_UNAVAIL   1

Definition at line 75 of file smtp.c.

◆ SMTP_AUTH_FAIL

#define SMTP_AUTH_FAIL   -1

Definition at line 76 of file smtp.c.

◆ SMTP_CAP_NO_FLAGS

#define SMTP_CAP_NO_FLAGS   0

No flags are set.

Definition at line 83 of file smtp.c.

◆ SMTP_CAP_STARTTLS

#define SMTP_CAP_STARTTLS   (1 << 0)

Server supports STARTTLS command.

Definition at line 84 of file smtp.c.

◆ SMTP_CAP_AUTH

#define SMTP_CAP_AUTH   (1 << 1)

Server supports AUTH command.

Definition at line 85 of file smtp.c.

◆ SMTP_CAP_DSN

#define SMTP_CAP_DSN   (1 << 2)

Server supports Delivery Status Notification.

Definition at line 86 of file smtp.c.

◆ SMTP_CAP_EIGHTBITMIME

#define SMTP_CAP_EIGHTBITMIME   (1 << 3)

Server supports 8-bit MIME content.

Definition at line 87 of file smtp.c.

◆ SMTP_CAP_SMTPUTF8

#define SMTP_CAP_SMTPUTF8   (1 << 4)

Server accepts UTF-8 strings.

Definition at line 88 of file smtp.c.

◆ SMTP_CAP_ALL

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

Definition at line 89 of file smtp.c.

Typedef Documentation

◆ SmtpCapFlags

typedef uint8_t SmtpCapFlags

SMTP server capabilities.

Flags, e.g. SMTP_CAP_STARTTLS

Definition at line 82 of file smtp.c.

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]bufString to check
[out]nNumeric value of code
Return values
trueValid number

Definition at line 129 of file smtp.c.

130{
131 return (mutt_str_atoi(buf, n) - buf) <= 3;
132}
const char * mutt_str_atoi(const char *str, int *dst)
Convert ASCII string to an integer.
Definition: atoi.c:192
+ 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
adataSMTP Account data
Return values
0Success (2xx code) or continue (354 code)
-1Write error, or any other response code

Definition at line 140 of file smtp.c.

141{
142 int n;
143 char buf[1024] = { 0 };
144
145 do
146 {
147 n = mutt_socket_readln(buf, sizeof(buf), adata->conn);
148 if (n < 4)
149 {
150 /* read error, or no response code */
151 return SMTP_ERR_READ;
152 }
153 const char *s = buf + 4; /* Skip the response code and the space/dash */
154 size_t plen;
155
156 if (mutt_istr_startswith(s, "8BITMIME"))
157 {
159 }
160 else if ((plen = mutt_istr_startswith(s, "AUTH ")))
161 {
162 adata->capabilities |= SMTP_CAP_AUTH;
163 FREE(&adata->auth_mechs);
164 adata->auth_mechs = mutt_str_dup(s + plen);
165 }
166 else if (mutt_istr_startswith(s, "DSN"))
167 {
168 adata->capabilities |= SMTP_CAP_DSN;
169 }
170 else if (mutt_istr_startswith(s, "STARTTLS"))
171 {
173 }
174 else if (mutt_istr_startswith(s, "SMTPUTF8"))
175 {
177 }
178
179 if (!valid_smtp_code(buf, &n))
180 return SMTP_ERR_CODE;
181
182 } while (buf[3] == '-');
183
184 if (smtp_success(n) || (n == SMTP_CONTINUE))
185 return 0;
186
187 mutt_error(_("SMTP session failed: %s"), buf);
188 return -1;
189}
#define mutt_error(...)
Definition: logging2.h:92
#define FREE(x)
Definition: memory.h:55
#define _(a)
Definition: message.h:28
char * mutt_str_dup(const char *str)
Copy a string, safely.
Definition: string.c:253
size_t mutt_istr_startswith(const char *str, const char *prefix)
Check whether a string starts with a prefix, ignoring case.
Definition: string.c:242
#define SMTP_CAP_STARTTLS
Server supports STARTTLS command.
Definition: smtp.c:84
#define SMTP_ERR_READ
Definition: smtp.c:67
static bool valid_smtp_code(char *buf, int *n)
Is the is a valid SMTP return code?
Definition: smtp.c:129
#define SMTP_ERR_CODE
Definition: smtp.c:69
#define SMTP_CAP_EIGHTBITMIME
Server supports 8-bit MIME content.
Definition: smtp.c:87
#define smtp_success(x)
Definition: smtp.c:63
#define SMTP_CAP_AUTH
Server supports AUTH command.
Definition: smtp.c:85
#define SMTP_CAP_SMTPUTF8
Server accepts UTF-8 strings.
Definition: smtp.c:88
#define SMTP_CONTINUE
Definition: smtp.c:65
#define SMTP_CAP_DSN
Server supports Delivery Status Notification.
Definition: smtp.c:86
#define mutt_socket_readln(buf, buflen, conn)
Definition: socket.h:56
struct Connection * conn
Server Connection.
Definition: smtp.c:99
const char * auth_mechs
Allowed authorisation mechanisms.
Definition: smtp.c:97
SmtpCapFlags capabilities
Server capabilities.
Definition: smtp.c:98
+ 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
adataSMTP Account data
alAddressList to use
Return values
0Success
<0Error, e.g. SMTP_ERR_WRITE

Definition at line 198 of file smtp.c.

199{
200 if (!al)
201 return 0;
202
203 const char *const c_dsn_notify = cs_subset_string(adata->sub, "dsn_notify");
204
205 struct Address *a = NULL;
206 TAILQ_FOREACH(a, al, entries)
207 {
208 /* weed out group mailboxes, since those are for display only */
209 if (!a->mailbox || a->group)
210 {
211 continue;
212 }
213 char buf[1024] = { 0 };
214 if ((adata->capabilities & SMTP_CAP_DSN) && c_dsn_notify)
215 {
216 snprintf(buf, sizeof(buf), "RCPT TO:<%s> NOTIFY=%s\r\n",
217 buf_string(a->mailbox), c_dsn_notify);
218 }
219 else
220 {
221 snprintf(buf, sizeof(buf), "RCPT TO:<%s>\r\n", buf_string(a->mailbox));
222 }
223 if (mutt_socket_send(adata->conn, buf) == -1)
224 return SMTP_ERR_WRITE;
225 int rc = smtp_get_resp(adata);
226 if (rc != 0)
227 return rc;
228 }
229
230 return 0;
231}
static const char * buf_string(const struct Buffer *buf)
Convert a buffer to a const char * "string".
Definition: buffer.h:96
const char * cs_subset_string(const struct ConfigSubset *sub, const char *name)
Get a string config item by name.
Definition: helpers.c:291
#define TAILQ_FOREACH(var, head, field)
Definition: queue.h:743
static int smtp_get_resp(struct SmtpAccountData *adata)
Read a command response from the SMTP server.
Definition: smtp.c:140
#define SMTP_ERR_WRITE
Definition: smtp.c:68
#define mutt_socket_send(conn, buf)
Definition: socket.h:57
An email address.
Definition: address.h:36
bool group
Group mailbox?
Definition: address.h:39
struct Buffer * mailbox
Mailbox and host address.
Definition: address.h:38
struct ConfigSubset * sub
Config scope.
Definition: smtp.c:100
+ 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
adataSMTP Account data
msgfileFilename containing data
Return values
0Success
<0Error, e.g. SMTP_ERR_WRITE

Definition at line 240 of file smtp.c.

241{
242 char buf[1024] = { 0 };
243 struct Progress *progress = NULL;
244 int rc = SMTP_ERR_WRITE;
245 int term = 0;
246 size_t buflen = 0;
247
248 FILE *fp = mutt_file_fopen(msgfile, "r");
249 if (!fp)
250 {
251 mutt_error(_("SMTP session failed: unable to open %s"), msgfile);
252 return -1;
253 }
254 const long size = mutt_file_get_size_fp(fp);
255 if (size == 0)
256 {
257 mutt_file_fclose(&fp);
258 return -1;
259 }
260 unlink(msgfile);
261 progress = progress_new(MUTT_PROGRESS_NET, size);
262 progress_set_message(progress, _("Sending message..."));
263
264 snprintf(buf, sizeof(buf), "DATA\r\n");
265 if (mutt_socket_send(adata->conn, buf) == -1)
266 {
267 mutt_file_fclose(&fp);
268 goto done;
269 }
270 rc = smtp_get_resp(adata);
271 if (rc != 0)
272 {
273 mutt_file_fclose(&fp);
274 goto done;
275 }
276
277 rc = SMTP_ERR_WRITE;
278 while (fgets(buf, sizeof(buf) - 1, fp))
279 {
280 buflen = mutt_str_len(buf);
281 term = buflen && buf[buflen - 1] == '\n';
282 if (term && ((buflen == 1) || (buf[buflen - 2] != '\r')))
283 snprintf(buf + buflen - 1, sizeof(buf) - buflen + 1, "\r\n");
284 if (buf[0] == '.')
285 {
286 if (mutt_socket_send_d(adata->conn, ".", MUTT_SOCK_LOG_FULL) == -1)
287 {
288 mutt_file_fclose(&fp);
289 goto done;
290 }
291 }
292 if (mutt_socket_send_d(adata->conn, buf, MUTT_SOCK_LOG_FULL) == -1)
293 {
294 mutt_file_fclose(&fp);
295 goto done;
296 }
297 progress_update(progress, MAX(0, ftell(fp)), -1);
298 }
299 if (!term && buflen &&
300 (mutt_socket_send_d(adata->conn, "\r\n", MUTT_SOCK_LOG_FULL) == -1))
301 {
302 mutt_file_fclose(&fp);
303 goto done;
304 }
305 mutt_file_fclose(&fp);
306
307 /* terminate the message body */
308 if (mutt_socket_send(adata->conn, ".\r\n") == -1)
309 goto done;
310
311 rc = smtp_get_resp(adata);
312
313done:
314 progress_free(&progress);
315 return rc;
316}
long mutt_file_get_size_fp(FILE *fp)
Get the size of a file.
Definition: file.c:1537
#define mutt_file_fclose(FP)
Definition: file.h:138
#define mutt_file_fopen(PATH, MODE)
Definition: file.h:137
#define MAX(a, b)
Definition: memory.h:31
size_t mutt_str_len(const char *a)
Calculate the length of a string, safely.
Definition: string.c:496
@ MUTT_PROGRESS_NET
Progress tracks bytes, according to $net_inc
Definition: lib.h:82
struct Progress * progress_new(enum ProgressType type, size_t size)
Create a new Progress Bar.
Definition: progress.c:139
void progress_free(struct Progress **ptr)
Free a Progress Bar.
Definition: progress.c:110
void progress_set_message(struct Progress *progress, const char *fmt,...) __attribute__((__format__(__printf__
bool progress_update(struct Progress *progress, size_t pos, int percent)
Update the state of the progress bar.
Definition: progress.c:80
#define MUTT_SOCK_LOG_FULL
Definition: socket.h:54
#define mutt_socket_send_d(conn, buf, dbg)
Definition: socket.h:58
+ 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
adataSMTP Account data
cacConnAccount to populate
Return values
0Success
-1Error

Definition at line 358 of file smtp.c.

359{
360 cac->flags = 0;
361 cac->port = 0;
363 cac->service = "smtp";
365 cac->gf_data = adata;
366
367 const char *const c_smtp_url = cs_subset_string(adata->sub, "smtp_url");
368
369 struct Url *url = url_parse(c_smtp_url);
370 if (!url || ((url->scheme != U_SMTP) && (url->scheme != U_SMTPS)) ||
371 !url->host || (account_from_url(cac, url) < 0))
372 {
373 url_free(&url);
374 mutt_error(_("Invalid SMTP URL: %s"), c_smtp_url);
375 return -1;
376 }
377
378 if (url->scheme == U_SMTPS)
379 cac->flags |= MUTT_ACCT_SSL;
380
381 if (cac->port == 0)
382 {
383 if (cac->flags & MUTT_ACCT_SSL)
384 {
385 cac->port = SMTPS_PORT;
386 }
387 else
388 {
389 static unsigned short SmtpPort = 0;
390 if (SmtpPort == 0)
391 {
392 struct servent *service = getservbyname("smtp", "tcp");
393 if (service)
394 SmtpPort = ntohs(service->s_port);
395 else
396 SmtpPort = SMTP_PORT;
397 mutt_debug(LL_DEBUG3, "Using default SMTP port %d\n", SmtpPort);
398 }
399 cac->port = SmtpPort;
400 }
401 }
402
403 url_free(&url);
404 return 0;
405}
#define MUTT_ACCT_SSL
Account uses SSL/TLS.
Definition: connaccount.h:47
static const char * smtp_get_field(enum ConnAccountField field, void *gf_data)
Get connection login credentials - Implements ConnAccount::get_field() -.
Definition: smtp.c:321
#define mutt_debug(LEVEL,...)
Definition: logging2.h:89
@ LL_DEBUG3
Log at debug level 3.
Definition: logging2.h:45
int account_from_url(struct ConnAccount *cac, const struct Url *url)
Fill ConnAccount with information from url.
Definition: mutt_account.c:44
@ MUTT_ACCT_TYPE_SMTP
Smtp Account.
Definition: mutt_account.h:38
#define SMTPS_PORT
Definition: smtp.c:72
#define SMTP_PORT
Definition: smtp.c:71
const char * service
Name of the service, e.g. "imap".
Definition: connaccount.h:61
const char *(* get_field)(enum ConnAccountField field, void *gf_data)
Definition: connaccount.h:70
unsigned char type
Connection type, e.g. MUTT_ACCT_TYPE_IMAP.
Definition: connaccount.h:59
MuttAccountFlags flags
Which fields are initialised, e.g. MUTT_ACCT_USER.
Definition: connaccount.h:60
void * gf_data
Private data to pass to get_field()
Definition: connaccount.h:72
unsigned short port
Port to connect to.
Definition: connaccount.h:58
A parsed URL proto://user:password@host:port/path?a=1&b=2
Definition: url.h:69
char * host
Host.
Definition: url.h:73
enum UrlScheme scheme
Scheme, e.g. U_SMTPS.
Definition: url.h:70
struct Url * url_parse(const char *src)
Fill in Url.
Definition: url.c:239
void url_free(struct Url **ptr)
Free the contents of a URL.
Definition: url.c:124
@ U_SMTPS
Url is smtps://.
Definition: url.h:44
@ U_SMTP
Url is smtp://.
Definition: url.h:43
+ 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
adataSMTP Account data
esmtpIf true, use ESMTP
Return values
0Success
<0Error, e.g. SMTP_ERR_WRITE

Definition at line 414 of file smtp.c.

415{
417
418 if (!esmtp)
419 {
420 /* if TLS or AUTH are requested, use EHLO */
421 if (adata->conn->account.flags & MUTT_ACCT_USER)
422 esmtp = true;
423#ifdef USE_SSL
424 const bool c_ssl_force_tls = cs_subset_bool(adata->sub, "ssl_force_tls");
425 const enum QuadOption c_ssl_starttls = cs_subset_quad(adata->sub, "ssl_starttls");
426
427 if (c_ssl_force_tls || (c_ssl_starttls != MUTT_NO))
428 esmtp = true;
429#endif
430 }
431
432 char buf[1024] = { 0 };
433 snprintf(buf, sizeof(buf), "%s %s\r\n", esmtp ? "EHLO" : "HELO", adata->fqdn);
434 /* XXX there should probably be a wrapper in mutt_socket.c that
435 * repeatedly calls adata->conn->write until all data is sent. This
436 * currently doesn't check for a short write. */
437 if (mutt_socket_send(adata->conn, buf) == -1)
438 return SMTP_ERR_WRITE;
439 return smtp_get_resp(adata);
440}
enum QuadOption cs_subset_quad(const struct ConfigSubset *sub, const char *name)
Get a quad-value config item by name.
Definition: helpers.c:192
bool cs_subset_bool(const struct ConfigSubset *sub, const char *name)
Get a boolean config item by name.
Definition: helpers.c:47
#define MUTT_ACCT_USER
User field has been set.
Definition: connaccount.h:44
QuadOption
Possible values for a quad-option.
Definition: quad.h:36
@ MUTT_NO
User answered 'No', or assume 'No'.
Definition: quad.h:38
#define SMTP_CAP_NO_FLAGS
No flags are set.
Definition: smtp.c:83
struct ConnAccount account
Account details: username, password, etc.
Definition: connection.h:49
const char * fqdn
Fully-qualified domain name.
Definition: smtp.c:101
+ 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
adataSMTP Account data
methodAuthentication method
xoauth2Use XOAUTH2 token (if true), OAUTHBEARER token otherwise
Return values
numResult, e.g. SMTP_AUTH_SUCCESS

Definition at line 732 of file smtp.c.

733{
734 /* If they did not explicitly request or configure oauth then fail quietly */
735 const char *const c_smtp_oauth_refresh_command = cs_subset_string(NeoMutt->sub, "smtp_oauth_refresh_command");
736 if (!method && !c_smtp_oauth_refresh_command)
737 return SMTP_AUTH_UNAVAIL;
738
739 const char *authtype = xoauth2 ? "XOAUTH2" : "OAUTHBEARER";
740
741 // L10N: (%s) is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
742 mutt_message(_("Authenticating (%s)..."), authtype);
743
744 /* We get the access token from the smtp_oauth_refresh_command */
745 char *oauthbearer = mutt_account_getoauthbearer(&adata->conn->account, xoauth2);
746 if (!oauthbearer)
747 return SMTP_AUTH_FAIL;
748
749 char *ibuf = NULL;
750 mutt_str_asprintf(&ibuf, "AUTH %s %s\r\n", authtype, oauthbearer);
751
752 int rc = mutt_socket_send(adata->conn, ibuf);
753 FREE(&oauthbearer);
754 FREE(&ibuf);
755
756 if (rc == -1)
757 return SMTP_AUTH_FAIL;
758 if (smtp_get_resp(adata) != 0)
759 return SMTP_AUTH_FAIL;
760
761 return SMTP_AUTH_SUCCESS;
762}
char * mutt_account_getoauthbearer(struct ConnAccount *cac, bool xoauth2)
Get an OAUTHBEARER/XOAUTH2 token.
Definition: connaccount.c:195
#define mutt_message(...)
Definition: logging2.h:91
int mutt_str_asprintf(char **strp, const char *fmt,...)
Definition: string.c:803
#define SMTP_AUTH_UNAVAIL
Definition: smtp.c:75
#define SMTP_AUTH_FAIL
Definition: smtp.c:76
#define SMTP_AUTH_SUCCESS
Definition: smtp.c:74
Container for Accounts, Notifications.
Definition: neomutt.h:42
struct ConfigSubset * sub
Inherited config items.
Definition: neomutt.h:46
+ 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
authenticatorAuthenticator string to check
Return values
trueArgument is a valid auth method

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

Definition at line 926 of file smtp.c.

927{
928 for (size_t i = 0; i < mutt_array_size(SmtpAuthenticators); i++)
929 {
930 const struct SmtpAuth *auth = &SmtpAuthenticators[i];
931 if (auth->method && mutt_istr_equal(auth->method, authenticator))
932 return true;
933 }
934
935 return false;
936}
#define mutt_array_size(x)
Definition: memory.h:38
bool mutt_istr_equal(const char *a, const char *b)
Compare two strings, ignoring case.
Definition: string.c:672
static const struct SmtpAuth SmtpAuthenticators[]
Accepted authentication methods.
Definition: smtp.c:903
SMTP authentication multiplexor.
Definition: smtp.c:108
const char * method
Name of authentication method supported, NULL means variable.
Definition: smtp.c:119
+ 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
adataSMTP Account data
Return values
0Success
<0Error, e.g. SMTP_AUTH_FAIL

Definition at line 944 of file smtp.c.

945{
946 int r = SMTP_AUTH_UNAVAIL;
947
948 const struct Slist *c_smtp_authenticators = cs_subset_slist(adata->sub, "smtp_authenticators");
949 if (c_smtp_authenticators && (c_smtp_authenticators->count > 0))
950 {
951 mutt_debug(LL_DEBUG2, "Trying user-defined smtp_authenticators\n");
952
953 /* Try user-specified list of authentication methods */
954 struct ListNode *np = NULL;
955 STAILQ_FOREACH(np, &c_smtp_authenticators->head, entries)
956 {
957 mutt_debug(LL_DEBUG2, "Trying method %s\n", np->data);
958
959 for (size_t i = 0; i < mutt_array_size(SmtpAuthenticators); i++)
960 {
961 const struct SmtpAuth *auth = &SmtpAuthenticators[i];
962 if (!auth->method || mutt_istr_equal(auth->method, np->data))
963 {
964 r = auth->authenticate(adata, np->data);
965 if (r == SMTP_AUTH_SUCCESS)
966 return r;
967 }
968 }
969 }
970 }
971 else
972 {
973 /* Fall back to default: any authenticator */
974#if defined(USE_SASL_CYRUS)
975 mutt_debug(LL_DEBUG2, "Falling back to smtp_auth_sasl, if using sasl\n");
976 r = smtp_auth_sasl(adata, adata->auth_mechs);
977#elif defined(USE_SASL_GNU)
978 mutt_debug(LL_DEBUG2, "Falling back to smtp_auth_gsasl, if using gsasl\n");
979 r = smtp_auth_gsasl(adata, adata->auth_mechs);
980#else
981 mutt_debug(LL_DEBUG2, "Falling back to using any authenticator available\n");
982 /* Try all available authentication methods */
983 for (size_t i = 0; i < mutt_array_size(SmtpAuthenticators); i++)
984 {
985 const struct SmtpAuth *auth = &SmtpAuthenticators[i];
986 mutt_debug(LL_DEBUG2, "Trying method %s\n", auth->method ? auth->method : "<variable>");
987 r = auth->authenticate(adata, auth->method);
988 if (r == SMTP_AUTH_SUCCESS)
989 return r;
990 }
991#endif
992 }
993
994 if (r != SMTP_AUTH_SUCCESS)
996
997 if (r == SMTP_AUTH_FAIL)
998 {
999 // L10N: %s is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
1000 mutt_error(_("%s authentication failed"), "SASL");
1001 }
1002 else if (r == SMTP_AUTH_UNAVAIL)
1003 {
1004 mutt_error(_("No authenticators available"));
1005 }
1006
1007 return (r == SMTP_AUTH_SUCCESS) ? 0 : -1;
1008}
const struct Slist * cs_subset_slist(const struct ConfigSubset *sub, const char *name)
Get a string-list config item by name.
Definition: helpers.c:242
void mutt_account_unsetpass(struct ConnAccount *cac)
Unset ConnAccount's password.
Definition: connaccount.c:177
@ LL_DEBUG2
Log at debug level 2.
Definition: logging2.h:44
#define STAILQ_FOREACH(var, head, field)
Definition: queue.h:352
A List node for strings.
Definition: list.h:37
char * data
String.
Definition: list.h:38
String list.
Definition: slist.h:37
struct ListHead head
List containing values.
Definition: slist.h:38
size_t count
Number of values in list.
Definition: slist.h:39
int(* authenticate)(struct SmtpAccountData *adata, const char *method)
Definition: smtp.c:117
+ 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
adataSMTP Account data
esmtpIf true, use ESMTP
Return values
0Success
-1Error

Definition at line 1017 of file smtp.c.

1018{
1019 int rc;
1020
1021 if (mutt_socket_open(adata->conn))
1022 return -1;
1023
1024 const bool force_auth = cs_subset_string(adata->sub, "smtp_user");
1025 esmtp |= force_auth;
1026
1027 /* get greeting string */
1028 rc = smtp_get_resp(adata);
1029 if (rc != 0)
1030 return rc;
1031
1032 rc = smtp_helo(adata, esmtp);
1033 if (rc != 0)
1034 return rc;
1035
1036#ifdef USE_SSL
1037 const bool c_ssl_force_tls = cs_subset_bool(adata->sub, "ssl_force_tls");
1038 enum QuadOption ans = MUTT_NO;
1039 if (adata->conn->ssf != 0)
1040 ans = MUTT_NO;
1041 else if (c_ssl_force_tls)
1042 ans = MUTT_YES;
1043 else if ((adata->capabilities & SMTP_CAP_STARTTLS) &&
1044 ((ans = query_quadoption(_("Secure connection with TLS?"),
1045 adata->sub, "ssl_starttls")) == MUTT_ABORT))
1046 {
1047 return -1;
1048 }
1049
1050 if (ans == MUTT_YES)
1051 {
1052 if (mutt_socket_send(adata->conn, "STARTTLS\r\n") < 0)
1053 return SMTP_ERR_WRITE;
1054 rc = smtp_get_resp(adata);
1055 // Clear any data after the STARTTLS acknowledgement
1056 mutt_socket_empty(adata->conn);
1057 if (rc != 0)
1058 return rc;
1059
1060 if (mutt_ssl_starttls(adata->conn))
1061 {
1062 mutt_error(_("Could not negotiate TLS connection"));
1063 return -1;
1064 }
1065
1066 /* re-EHLO to get authentication mechanisms */
1067 rc = smtp_helo(adata, esmtp);
1068 if (rc != 0)
1069 return rc;
1070 }
1071#endif
1072
1073 if (force_auth || adata->conn->account.flags & MUTT_ACCT_USER)
1074 {
1075 if (!(adata->capabilities & SMTP_CAP_AUTH))
1076 {
1077 mutt_error(_("SMTP server does not support authentication"));
1078 return -1;
1079 }
1080
1081 return smtp_authenticate(adata);
1082 }
1083
1084 return 0;
1085}
int mutt_ssl_starttls(struct Connection *conn)
Negotiate TLS over an already opened connection.
Definition: gnutls.c:1146
@ MUTT_ABORT
User aborted the question (with Ctrl-G)
Definition: quad.h:37
@ MUTT_YES
User answered 'Yes', or assume 'Yes'.
Definition: quad.h:39
enum QuadOption query_quadoption(const char *prompt, struct ConfigSubset *sub, const char *name)
Ask the user a quad-question.
Definition: question.c:379
static int smtp_authenticate(struct SmtpAccountData *adata)
Authenticate to an SMTP server.
Definition: smtp.c:944
static int smtp_helo(struct SmtpAccountData *adata, bool esmtp)
Say hello to an SMTP Server.
Definition: smtp.c:414
void mutt_socket_empty(struct Connection *conn)
Clear out any queued data.
Definition: socket.c:306
int mutt_socket_open(struct Connection *conn)
Simple wrapper.
Definition: socket.c:76
unsigned int ssf
Security strength factor, in bits (see notes)
Definition: connection.h:50
+ 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
fromFrom Address
toTo Address
ccCc Address
bccBcc Address
msgfileMessage to send to the server
eightbitIf true, try for an 8-bit friendly connection
subConfig Subset
Return values
0Success
-1Error

Definition at line 1099 of file smtp.c.

1102{
1103 struct SmtpAccountData adata = { 0 };
1104 struct ConnAccount cac = { { 0 } };
1105 const char *envfrom = NULL;
1106 int rc = -1;
1107
1108 adata.sub = sub;
1109 adata.fqdn = mutt_fqdn(false, adata.sub);
1110 if (!adata.fqdn)
1111 adata.fqdn = NONULL(ShortHostname);
1112
1113 const struct Address *c_envelope_from_address = cs_subset_address(adata.sub, "envelope_from_address");
1114
1115 if (smtp_fill_account(&adata, &cac) < 0)
1116 return rc;
1117
1118 adata.conn = mutt_conn_find(&cac);
1119 if (!adata.conn)
1120 return -1;
1121
1122 /* it might be better to synthesize an envelope from from user and host
1123 * but this condition is most likely arrived at accidentally */
1124 if (c_envelope_from_address)
1125 {
1126 envfrom = buf_string(c_envelope_from_address->mailbox);
1127 }
1128 else if (from && !TAILQ_EMPTY(from))
1129 {
1130 envfrom = buf_string(TAILQ_FIRST(from)->mailbox);
1131 }
1132 else
1133 {
1134 mutt_error(_("No from address given"));
1135 mutt_socket_close(adata.conn);
1136 return -1;
1137 }
1138
1139 const char *const c_dsn_return = cs_subset_string(adata.sub, "dsn_return");
1140
1141 struct Buffer *buf = buf_pool_get();
1142 do
1143 {
1144 /* send our greeting */
1145 rc = smtp_open(&adata, eightbit);
1146 if (rc != 0)
1147 break;
1148 FREE(&adata.auth_mechs);
1149
1150 /* send the sender's address */
1151 buf_printf(buf, "MAIL FROM:<%s>", envfrom);
1152 if (eightbit && (adata.capabilities & SMTP_CAP_EIGHTBITMIME))
1153 buf_addstr(buf, " BODY=8BITMIME");
1154
1155 if (c_dsn_return && (adata.capabilities & SMTP_CAP_DSN))
1156 buf_add_printf(buf, " RET=%s", c_dsn_return);
1157
1158 if ((adata.capabilities & SMTP_CAP_SMTPUTF8) &&
1161 {
1162 buf_addstr(buf, " SMTPUTF8");
1163 }
1164 buf_addstr(buf, "\r\n");
1165 if (mutt_socket_send(adata.conn, buf_string(buf)) == -1)
1166 {
1167 rc = SMTP_ERR_WRITE;
1168 break;
1169 }
1170 rc = smtp_get_resp(&adata);
1171 if (rc != 0)
1172 break;
1173
1174 /* send the recipient list */
1175 if ((rc = smtp_rcpt_to(&adata, to)) || (rc = smtp_rcpt_to(&adata, cc)) ||
1176 (rc = smtp_rcpt_to(&adata, bcc)))
1177 {
1178 break;
1179 }
1180
1181 /* send the message data */
1182 rc = smtp_data(&adata, msgfile);
1183 if (rc != 0)
1184 break;
1185
1186 mutt_socket_send(adata.conn, "QUIT\r\n");
1187
1188 rc = 0;
1189 } while (false);
1190
1191 mutt_socket_close(adata.conn);
1192 FREE(&adata.conn);
1193
1194 if (rc == SMTP_ERR_READ)
1195 mutt_error(_("SMTP session failed: read error"));
1196 else if (rc == SMTP_ERR_WRITE)
1197 mutt_error(_("SMTP session failed: write error"));
1198 else if (rc == SMTP_ERR_CODE)
1199 mutt_error(_("Invalid server response"));
1200
1201 buf_pool_release(&buf);
1202 return rc;
1203}
bool mutt_addrlist_uses_unicode(const struct AddressList *al)
Do any of a list of addresses use Unicode characters.
Definition: address.c:1522
bool mutt_addr_uses_unicode(const char *str)
Does this address use Unicode character.
Definition: address.c:1502
const struct Address * cs_subset_address(const struct ConfigSubset *sub, const char *name)
Get an Address config item by name.
Definition: config_type.c:272
int buf_printf(struct Buffer *buf, const char *fmt,...)
Format a string overwriting a Buffer.
Definition: buffer.c:161
int buf_add_printf(struct Buffer *buf, const char *fmt,...)
Format a string appending a Buffer.
Definition: buffer.c:204
size_t buf_addstr(struct Buffer *buf, const char *s)
Add a string to a Buffer.
Definition: buffer.c:226
char * ShortHostname
Short version of the hostname.
Definition: globals.c:38
struct Connection * mutt_conn_find(const struct ConnAccount *cac)
Find a connection from a list.
Definition: mutt_socket.c:89
struct Buffer * buf_pool_get(void)
Get a Buffer from the pool.
Definition: pool.c:82
void buf_pool_release(struct Buffer **ptr)
Return a Buffer to the pool.
Definition: pool.c:96
#define TAILQ_FIRST(head)
Definition: queue.h:741
#define TAILQ_EMPTY(head)
Definition: queue.h:739
const char * mutt_fqdn(bool may_hide_host, const struct ConfigSubset *sub)
Get the Fully-Qualified Domain Name.
Definition: sendlib.c:707
static int smtp_data(struct SmtpAccountData *adata, const char *msgfile)
Send data to an SMTP server.
Definition: smtp.c:240
static int smtp_fill_account(struct SmtpAccountData *adata, struct ConnAccount *cac)
Create ConnAccount object from SMTP Url.
Definition: smtp.c:358
static int smtp_rcpt_to(struct SmtpAccountData *adata, const struct AddressList *al)
Set the recipient to an Address.
Definition: smtp.c:198
static int smtp_open(struct SmtpAccountData *adata, bool esmtp)
Open an SMTP Connection.
Definition: smtp.c:1017
int mutt_socket_close(struct Connection *conn)
Close a socket.
Definition: socket.c:100
#define NONULL(x)
Definition: string2.h:37
String manipulation buffer.
Definition: buffer.h:36
Login details for a remote server.
Definition: connaccount.h:53
Server connection data.
Definition: smtp.c:96
+ 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" },
}
static int smtp_auth_xoauth2(struct SmtpAccountData *adata, const char *method)
Authenticate an SMTP connection using XOAUTH2 - Implements SmtpAuth::authenticate() -.
Definition: smtp.c:781
static int smtp_auth_login(struct SmtpAccountData *adata, const char *method)
Authenticate using plain text - Implements SmtpAuth::authenticate() -.
Definition: smtp.c:835
static int smtp_auth_plain(struct SmtpAccountData *adata, const char *method)
Authenticate using plain text - Implements SmtpAuth::authenticate() -.
Definition: smtp.c:795
static int smtp_auth_oauth(struct SmtpAccountData *adata, const char *method)
Authenticate an SMTP connection using OAUTHBEARER - Implements SmtpAuth::authenticate() -.
Definition: smtp.c:770

Accepted authentication methods.

Definition at line 903 of file smtp.c.