smtp.h File Reference

Send email to an SMTP server. More...

#include "config.h"
#include <stdbool.h>

Include dependency graph for smtp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
bool	smtp_auth_is_valid (const char *authenticator)
	Check if string is a valid smtp authentication method.
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.

Detailed Description

Send email to an SMTP server.

Authors

• Pietro Cerutti
• Richard Russon

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.h.

Function Documentation

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 926 of file smtp.c.

{
  for (size_t i = 0; i < mutt_array_size(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:

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 1099 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);
 
  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: