From cee5fbe35ef7c5b6d0593dc5c35b1c40b74eed38 Mon Sep 17 00:00:00 2001 From: Pierre Habouzit Date: Tue, 10 Apr 2007 10:07:40 +0200 Subject: [PATCH] rename mutt_libesmtp -> send_smtp Signed-off-by: Pierre Habouzit --- send_smtp.c | 404 ++++++++++++++++++++++++++++++++++++++++++++++++++++ send_smtp.h | 24 ++++ 2 files changed, 428 insertions(+) create mode 100644 send_smtp.c create mode 100644 send_smtp.h diff --git a/send_smtp.c b/send_smtp.c new file mode 100644 index 0000000..32f4ba0 --- /dev/null +++ b/send_smtp.c @@ -0,0 +1,404 @@ +/* + * Copyright notice from original mutt: + * [none] + * + * Parts were written/modified by: + * Christian Gall + * Rocco Rutte + * + * This file is part of mutt-ng, see http://www.muttng.org/. + * It's licensed under the GNU General Public License, + * please see the file GPL in the top level source directory. + */ + +#include + +#if defined(USE_SSL) || (defined(USE_GNUTLS) && defined(HAVE_GNUTLS_OPENSSL_H)) +#include +#endif + +#include +#include + +#include +#include +#include "mutt.h" +#include "send_smtp.h" + +static char authpass[STRING] = ""; + +#define FAIL() \ + do { \ + ret = -1; \ + goto Done; \ + } while (0) +#define MSGFAIL(msg) \ + do { \ + mutt_error("%s", msg); \ + FAIL(); \ + } while (0) +#define LIBCFAIL(msg) \ + do { \ + mutt_error("%s: %s", msg, strerror(errno)); \ + FAIL(); \ + } while (0) +#define SMTPFAIL(msg) \ + do { \ + _send_smtp_perror(msg); \ + FAIL(); \ + } while (0) +#define extna(msg) { mutt_error (_("SMTP Extension '%s' not supported by MTA."), \ + msg); sleep (1); } + +/* + * _send_smtp_ensure_init + * Make sure the libESMTP support in mutt is initialized at some time. + */ +static void _send_smtp_ensure_init () +{ + static int libesmtp_init = 0; + + if (!libesmtp_init) { + if (SmtpAuthUser) + auth_client_init (); + libesmtp_init = 1; + } +} + +/* + * _send_smtp_perror + * Prints 'msg', a colon, and then a string representation of the + * libesmtp errno as a mutt error. + */ +static void _send_smtp_perror (const char *msg) +{ + char buf[512]; + + mutt_error ("%s: %s", msg, + smtp_strerror (smtp_errno (), buf, sizeof (buf))); +} + +/* + * _send_smtp_add_recipients + * Adds every address in 'addr' as a recipient to the smtp message + * 'message'. Note that this does not mean that they will necessarily + * show up in the mail headers (e.g., when bcc'ing). Returns 0 upon + * success, -1 upon failure (and prints an error message). + * + * Very similar to sendlib.c::add_args + */ +static int +_send_smtp_add_recipients (smtp_message_t message, address_t * addr) +{ + int ret = 0; + + for (; addr; addr = addr->next) { + /* weed out group mailboxes, since those are for display only */ + if (addr->mailbox && !addr->group) { + if (!smtp_add_recipient (message, addr->mailbox)) + SMTPFAIL ("smtp_add_recipient"); + } + } + +Done: + return ret; +} + +static int +_send_smtp_auth_interact (auth_client_request_t request, + char **result, int fields, + void *arg __attribute__ ((unused))) +{ + int i; + + for (i = 0; i < fields; i++) { + if (request[i].flags & AUTH_USER) { + result[i] = SmtpAuthUser; + } else if (request[i].flags & AUTH_PASS) { + if (SmtpAuthPass) { + result[i] = SmtpAuthPass; + } else { + if (authpass[0] == '\0') { + char prompt[STRING]; + + snprintf(prompt, sizeof(prompt), "%s%s: ", request[i].prompt, + request[i].flags & AUTH_CLEARTEXT ? " (not encrypted)" : + ""); + mutt_get_field_unbuffered(prompt, authpass, sizeof(authpass), + M_PASS); + } + result[i] = authpass; + } + } + } + + return 1; +} + +#define BUFLEN 8192 + +static const char * +_send_smtp_messagefp_cb(void **buf, int *len, void *arg) +{ + int octets; + + if (*buf == NULL) + *buf = xmalloc(BUFLEN); + + if (len == NULL) { + rewind ((FILE *) arg); + return NULL; + } + + if (fgets (*buf, BUFLEN - 2, (FILE *) arg) == NULL) { + octets = 0; + } + else { + char *p = strchr (*buf, '\0'); + + if (p[-1] == '\n' && p[-2] != '\r') { + m_strcpy(p - 1, (char *) *buf + BUFLEN - p + 1, "\r\n"); + p++; + } + octets = p - (char *) *buf; + } + + *len = octets; + return *buf; +} + +static int handle_invalid_peer_certificate (long vfy_result) { +#if defined (USE_SSL) || (defined (USE_GNUTLS) && defined (HAVE_GNUTLS_OPENSSL_H)) + mutt_error (_("Error verifying certificate: %s"), + NONULL (X509_verify_cert_error_string (vfy_result))); +#else + mutt_error (_("Error verifying certificate. Error Code: %lu"), vfy_result); +#endif + sleep(2); + return 1; /* Accept the problem */ +} + +static void event_cb (smtp_session_t session __attribute__ ((unused)), + int event_no, void *arg,...) +{ + va_list alist; + int *ok; + + va_start(alist, arg); + switch(event_no) { + case SMTP_EV_CONNECT: + case SMTP_EV_MAILSTATUS: + case SMTP_EV_RCPTSTATUS: + case SMTP_EV_MESSAGEDATA: + case SMTP_EV_MESSAGESENT: + case SMTP_EV_DISCONNECT: break; + case SMTP_EV_WEAK_CIPHER: { + int bits; + bits = va_arg(alist, long); ok = va_arg(alist, int*); + mutt_message (_("SMTP_EV_WEAK_CIPHER, bits=%d - accepted."), bits); + sleep(1); + *ok = 1; break; + } + case SMTP_EV_STARTTLS_OK: + mutt_message (_("Using TLS")); + sleep(1); + break; + case SMTP_EV_INVALID_PEER_CERTIFICATE: { + long vfy_result; + vfy_result = va_arg(alist, long); ok = va_arg(alist, int*); + *ok = handle_invalid_peer_certificate(vfy_result); + sleep(1); + break; + } + case SMTP_EV_NO_PEER_CERTIFICATE: { + ok = va_arg(alist, int*); + mutt_message (_("SMTP_EV_NO_PEER_CERTIFICATE - accepted.")); + sleep(1); + *ok = 1; break; + } + case SMTP_EV_WRONG_PEER_CERTIFICATE: { + ok = va_arg(alist, int*); + mutt_message (_("SMTP_EV_WRONG_PEER_CERTIFICATE - accepted.")); + sleep(1); + *ok = 1; break; + } + case SMTP_EV_NO_CLIENT_CERTIFICATE: { + ok = va_arg(alist, int*); + mutt_message (_("SMTP_EV_NO_CLIENT_CERTIFICATE - accepted.")); + sleep(1); + *ok = 1; break; + } + case SMTP_EV_EXTNA_DSN: + extna ("DSN"); + break; + case SMTP_EV_EXTNA_STARTTLS: + extna ("StartTLS"); + break; + case SMTP_EV_EXTNA_8BITMIME: + extna ("8BITMIME"); + break; + default: + mutt_message(_("Got unhandled event ID = %d - ignored."), event_no); + sleep(1); + } + va_end(alist); +} + +static void do_dsn_notify (smtp_message_t message, const char* from) { + int flags = Notify_NOTSET; + smtp_recipient_t self = NULL; + + if (m_strisempty(MTransport.dsn_notify) || !message || m_strisempty(from) || + strstr (MTransport.dsn_notify, "never") != NULL) + return; + + if (strstr (MTransport.dsn_notify, "failure") != NULL) + flags |= Notify_FAILURE; + if (strstr (MTransport.dsn_notify, "delay") != NULL) + flags |= Notify_DELAY; + if (strstr (MTransport.dsn_notify, "success") != NULL) + flags |= Notify_SUCCESS; + + if (flags != Notify_NOTSET) { + if (!(self = smtp_add_recipient (message, from))) + return; + smtp_dsn_set_notify (self, flags); + } +} + +static void do_dsn_ret (smtp_message_t message) { + if (m_strisempty(MTransport.dsn_return) || !message) + return; + if (ascii_strncasecmp (MTransport.dsn_return, "hdrs", 4) == 0) + smtp_dsn_set_ret (message, Ret_HDRS); + else if (ascii_strncasecmp (MTransport.dsn_return, "full", 4) == 0) + smtp_dsn_set_ret (message, Ret_FULL); +} + +#if defined (USE_LIBESMTP) && (defined (USE_SSL) || defined (USE_GNUTLS)) +int send_smtp_check_usetls (const char* option, unsigned long p, + char* errbuf, ssize_t errlen) { + char* val = (char*) p; + if (m_strisempty(val)) + return (1); + if (m_strncmp(val, "enabled", 7) != 0 && + m_strncmp(val, "required", 8) != 0) { + if (errbuf) + snprintf (errbuf, errlen, _("'%s' is invalid for %s"), val, option); + return (0); + } + return (1); +} +#endif + +/* + * send_smtp_invoke + * Sends a mail message to the provided recipients using libesmtp. + * Returns 0 upon success, -1 upon failure (and prints an error + * message). + */ +int send_smtp_invoke (address_t * from, /* the sender */ + address_t * to, address_t * cc, address_t * bcc, /* recips */ + const char *msg, /* file containing message */ + int eightbit) +{ /* message contains 8bit chars */ + int ret = 0; /* return value, default = success */ + smtp_session_t session; + smtp_message_t message; + char *hostportstr = NULL; + size_t hostportlen; + FILE *fp = NULL; + auth_context_t authctx = NULL; + const smtp_status_t *status; + char* envfrom = from->mailbox; + + _send_smtp_ensure_init (); + + if ((session = smtp_create_session ()) == NULL) + SMTPFAIL ("smtp_create_session"); + +#if defined (USE_SSL) || (defined (USE_GNUTLS) && defined (HAVE_GNUTLS_OPENSSL_H)) + if (SmtpUseTLS != NULL && ascii_strncasecmp("enabled", SmtpUseTLS, 7) == 0) { + smtp_starttls_enable(session, Starttls_ENABLED); + } else if (SmtpUseTLS != NULL && ascii_strncasecmp("required", SmtpUseTLS, 8) == 0) { + smtp_starttls_enable(session, Starttls_REQUIRED); + } +#endif + + /* Create hostname:port string and tell libesmtp */ + /* len = SmtpHost len + colon + max port (65536 => 5 chars) + terminator */ + hostportlen = m_strlen(SmtpHost) + 7; + hostportstr = p_new(char, hostportlen); + snprintf (hostportstr, hostportlen, "%s:%d", SmtpHost, SmtpPort); + if (!smtp_set_server (session, hostportstr)) + SMTPFAIL ("smtp_set_server"); + + if (SmtpAuthUser) { + if ((authctx = auth_create_context ()) == NULL) + MSGFAIL ("auth_create_context failed"); + auth_set_mechanism_flags (authctx, AUTH_PLUGIN_PLAIN, 0); + auth_set_interact_cb (authctx, _send_smtp_auth_interact, NULL); + + if (!smtp_auth_set_context (session, authctx)) + SMTPFAIL ("smtp_auth_set_context"); + } + +#if defined (USE_SSL) || (defined (USE_GNUTLS) && defined (HAVE_GNUTLS_OPENSSL_H)) + smtp_starttls_set_ctx (session, NULL); +#endif + smtp_set_eventcb (session, event_cb, NULL); + + if ((message = smtp_add_message (session)) == NULL) + SMTPFAIL ("smtp_add_message"); + + /* Initialize envelope sender */ + if (MTransport.use_envelope_from && MTransport.envelope_from_address) + envfrom = MTransport.envelope_from_address->mailbox; + if (!smtp_set_reverse_path (message, envfrom)) + SMTPFAIL ("smtp_set_reverse_path"); + + /* set up DSN for message */ + do_dsn_notify (message, envfrom); + do_dsn_ret (message); + + /* set up 8bitmime flag */ + if (eightbit && MTransport.use_8bitmime) + smtp_8bitmime_set_body (message, E8bitmime_8BITMIME); + + if ((fp = fopen (msg, "r")) == NULL) + LIBCFAIL ("fopen"); + if (!smtp_set_messagecb (message, _send_smtp_messagefp_cb, fp)) + SMTPFAIL ("smtp_set_messagecb"); + if (_send_smtp_add_recipients (message, to)) + FAIL (); + if (_send_smtp_add_recipients (message, cc)) + FAIL (); + if (_send_smtp_add_recipients (message, bcc)) + FAIL (); + if (!smtp_start_session (session)) + SMTPFAIL ("smtp_start_session"); + + status = smtp_message_transfer_status (message); + if (status->code < 200 || status->code > 299) { + char buf[256]; + + snprintf (buf, sizeof (buf), "SMTP error while sending: %d %s", + status->code, status->text); + MSGFAIL (buf); + } + +Done: + m_fclose(&fp); + if (hostportstr != NULL) + p_delete(&hostportstr); + if (session != NULL) + smtp_destroy_session (session); + if (authctx != NULL) + auth_destroy_context (authctx); + + /* Forget user-entered SMTP AUTH password if send fails */ + if (ret != 0) + authpass[0] = '\0'; + + return ret; +} diff --git a/send_smtp.h b/send_smtp.h new file mode 100644 index 0000000..1733d58 --- /dev/null +++ b/send_smtp.h @@ -0,0 +1,24 @@ +/* + * Copyright notice from original mutt: + * [none] + * + * This file is part of mutt-ng, see http://www.muttng.org/. + * It's licensed under the GNU General Public License, + * please see the file GPL in the top level source directory. + */ + +#ifndef _MUTT_LIBESMTP_H +#define _MUTT_LIBESMTP_H + +#ifdef USE_LIBESMTP +#if (defined (USE_SSL) || defined (USE_GNUTLS)) +int send_smtp_check_usetls (const char* option, unsigned long p, + char* errbuf, ssize_t errlen); +#endif + +int send_smtp_invoke(address_t * from, /* the sender */ + address_t * to, address_t * cc, address_t * bcc, + const char *msg, int eightbit); +#endif + +#endif /* !_MUTT_LIBESMTP_H */ -- 2.20.1