mutt_libesmtp.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * [none]
   4  *
   5  * Parts were written/modified by:
   6  * Christian Gall <cg@cgall.de>
   7  * Rocco Rutte <pdmef@cs.tu-berlin.de>
   8  *
   9  * This file is part of mutt-ng, see http://www.muttng.org/.
  10  * It's licensed under the GNU General Public License,
  11  * please see the file GPL in the top level source directory.
  12  */
  13
  14 #include <lib-lib/lib-lib.h>
  15
  16 #include <lib-ui/enter.h>
  17
  18 #include "mutt.h"
  19
  20
  21 #if defined (USE_SSL) || (defined (USE_GNUTLS) && defined (HAVE_GNUTLS_OPENSSL_H))
  22 #include <openssl/ssl.h>
  23 #endif
  24
  25 #include <auth-client.h>
  26 #include <libesmtp.h>
  27
  28 static char authpass[STRING] = "";
  29
  30 #define FAIL() \
  31   do { \
  32     ret = -1; \
  33     goto Done; \
  34   } while (0)
  35 #define MSGFAIL(msg) \
  36   do { \
  37     mutt_error("%s", msg); \
  38     FAIL(); \
  39   } while (0)
  40 #define LIBCFAIL(msg) \
  41   do { \
  42     mutt_error("%s: %s", msg, strerror(errno)); \
  43     FAIL(); \
  44   } while (0)
  45 #define SMTPFAIL(msg) \
  46   do { \
  47     _mutt_libesmtp_perror(msg); \
  48     FAIL(); \
  49   } while (0)
  50 #define extna(msg) { mutt_error (_("SMTP Extension '%s' not supported by MTA."), \
  51                                  msg); sleep (1); }
  52
  53 /*
  54  * _mutt_libesmtp_ensure_init
  55  *   Make sure the libESMTP support in mutt is initialized at some time.
  56  */
  57 static void _mutt_libesmtp_ensure_init ()
  58 {
  59   static int libesmtp_init = 0;
  60
  61   if (!libesmtp_init) {
  62     if (SmtpAuthUser)
  63       auth_client_init ();
  64     libesmtp_init = 1;
  65   }
  66 }
  67
  68 /*
  69  * _mutt_libesmtp_perror
  70  *   Prints 'msg', a colon, and then a string representation of the
  71  *   libesmtp errno as a mutt error.
  72  */
  73 static void _mutt_libesmtp_perror (const char *msg)
  74 {
  75   char buf[512];
  76
  77   mutt_error ("%s: %s", msg,
  78               smtp_strerror (smtp_errno (), buf, sizeof (buf)));
  79 }
  80
  81 /*
  82  * _mutt_libesmtp_add_recipients
  83  *   Adds every address in 'addr' as a recipient to the smtp message
  84  *   'message'.  Note that this does not mean that they will necessarily
  85  *   show up in the mail headers (e.g., when bcc'ing).  Returns 0 upon
  86  *   success, -1 upon failure (and prints an error message).
  87  *
  88  *   Very similar to sendlib.c::add_args
  89  */
  90 static int
  91 _mutt_libesmtp_add_recipients (smtp_message_t message, address_t * addr)
  92 {
  93   int ret = 0;
  94
  95   for (; addr; addr = addr->next) {
  96     /* weed out group mailboxes, since those are for display only */
  97     if (addr->mailbox && !addr->group) {
  98       if (!smtp_add_recipient (message, addr->mailbox))
  99         SMTPFAIL ("smtp_add_recipient");
 100     }
 101   }
 102
 103 Done:
 104   return ret;
 105 }
 106
 107 static int
 108 _mutt_libesmtp_auth_interact (auth_client_request_t request,
 109                               char **result, int fields, void *arg)
 110 {
 111   int i;
 112
 113   for (i = 0; i < fields; i++) {
 114     if (request[i].flags & AUTH_USER) {
 115       result[i] = SmtpAuthUser;
 116     }
 117     else if (request[i].flags & AUTH_PASS) {
 118       if (SmtpAuthPass) {
 119         result[i] = SmtpAuthPass;
 120       }
 121       else {
 122         if (authpass[0] == '\0') {
 123           char prompt[STRING];
 124
 125           snprintf (prompt, sizeof (prompt), "%s%s: ", request[i].prompt,
 126                     (request[i].
 127                      flags & AUTH_CLEARTEXT) ? " (not encrypted)" : "");
 128           mutt_get_field_unbuffered (prompt, authpass, sizeof (authpass),
 129                                      M_PASS);
 130         }
 131         result[i] = authpass;
 132       }
 133     }
 134   }
 135
 136   return 1;
 137 }
 138
 139 #define BUFLEN 8192
 140
 141 static const char *_mutt_libesmtp_messagefp_cb (void **buf, int *len,
 142                                                 void *arg)
 143 {
 144   int octets;
 145
 146   if (*buf == NULL)
 147     *buf = xmalloc(BUFLEN);
 148
 149   if (len == NULL) {
 150     rewind ((FILE *) arg);
 151     return NULL;
 152   }
 153
 154   if (fgets (*buf, BUFLEN - 2, (FILE *) arg) == NULL) {
 155     octets = 0;
 156   }
 157   else {
 158     char *p = strchr (*buf, '\0');
 159
 160     if (p[-1] == '\n' && p[-2] != '\r') {
 161       m_strcpy(p - 1, (char *) *buf + BUFLEN - p + 1, "\r\n");
 162       p++;
 163     }
 164     octets = p - (char *) *buf;
 165   }
 166
 167   *len = octets;
 168   return *buf;
 169 }
 170
 171 static int handle_invalid_peer_certificate (long vfy_result) {
 172 #if defined (USE_SSL) || (defined (USE_GNUTLS) && defined (HAVE_GNUTLS_OPENSSL_H))
 173   mutt_error (_("Error verifying certificate: %s"),
 174               NONULL (X509_verify_cert_error_string (vfy_result)));
 175 #else
 176   mutt_error (_("Error verifying certificate. Error Code: %lu"), vfy_result);
 177 #endif
 178   sleep(2);
 179   return 1; /* Accept the problem */
 180 }
 181
 182 static void event_cb (smtp_session_t session, int event_no, void *arg,...)
 183 {
 184   va_list alist;
 185   int *ok;
 186
 187   va_start(alist, arg);
 188   switch(event_no) {
 189   case SMTP_EV_CONNECT:
 190   case SMTP_EV_MAILSTATUS:
 191   case SMTP_EV_RCPTSTATUS:
 192   case SMTP_EV_MESSAGEDATA:
 193   case SMTP_EV_MESSAGESENT:
 194   case SMTP_EV_DISCONNECT: break;
 195   case SMTP_EV_WEAK_CIPHER: {
 196     int bits;
 197     bits = va_arg(alist, long); ok = va_arg(alist, int*);
 198     mutt_message (_("SMTP_EV_WEAK_CIPHER, bits=%d - accepted."), bits);
 199     sleep(1);
 200     *ok = 1; break;
 201   }
 202   case SMTP_EV_STARTTLS_OK:
 203     mutt_message (_("Using TLS"));
 204     sleep(1);
 205     break;
 206   case SMTP_EV_INVALID_PEER_CERTIFICATE: {
 207     long vfy_result;
 208     vfy_result = va_arg(alist, long); ok = va_arg(alist, int*);
 209     *ok = handle_invalid_peer_certificate(vfy_result);
 210     sleep(1);
 211     break;
 212   }
 213   case SMTP_EV_NO_PEER_CERTIFICATE: {
 214     ok = va_arg(alist, int*);
 215     mutt_message (_("SMTP_EV_NO_PEER_CERTIFICATE - accepted."));
 216     sleep(1);
 217     *ok = 1; break;
 218   }
 219   case SMTP_EV_WRONG_PEER_CERTIFICATE: {
 220     ok = va_arg(alist, int*);
 221     mutt_message (_("SMTP_EV_WRONG_PEER_CERTIFICATE - accepted."));
 222     sleep(1);
 223     *ok = 1; break;
 224   }
 225   case SMTP_EV_NO_CLIENT_CERTIFICATE: {
 226     ok = va_arg(alist, int*);
 227     mutt_message (_("SMTP_EV_NO_CLIENT_CERTIFICATE - accepted."));
 228     sleep(1);
 229     *ok = 1; break;
 230   }
 231   case SMTP_EV_EXTNA_DSN:
 232     extna ("DSN");
 233     break;
 234   case SMTP_EV_EXTNA_STARTTLS:
 235     extna ("StartTLS");
 236     break;
 237   case SMTP_EV_EXTNA_8BITMIME:
 238     extna ("8BITMIME");
 239     break;
 240   default:
 241     mutt_message(_("Got unhandled event ID = %d - ignored."), event_no);
 242     sleep(1);
 243   }
 244   va_end(alist);
 245 }
 246
 247 static void do_dsn_notify (smtp_message_t message, const char* from) {
 248   int flags = Notify_NOTSET;
 249   smtp_recipient_t self = NULL;
 250
 251   if (m_strisempty(DsnNotify) || !message || m_strisempty(from) ||
 252       strstr (DsnNotify, "never") != NULL)
 253     return;
 254
 255   if (strstr (DsnNotify, "failure") != NULL)
 256     flags |= Notify_FAILURE;
 257   if (strstr (DsnNotify, "delay") != NULL)
 258     flags |= Notify_DELAY;
 259   if (strstr (DsnNotify, "success") != NULL)
 260     flags |= Notify_SUCCESS;
 261
 262   if (flags != Notify_NOTSET) {
 263     if (!(self = smtp_add_recipient (message, from)))
 264       return;
 265     smtp_dsn_set_notify (self, flags);
 266   }
 267 }
 268
 269 static void do_dsn_ret (smtp_message_t message) {
 270   if (m_strisempty(DsnReturn) || !message)
 271     return;
 272   if (ascii_strncasecmp (DsnReturn, "hdrs", 4) == 0)
 273     smtp_dsn_set_ret (message, Ret_HDRS);
 274   else if (ascii_strncasecmp (DsnReturn, "full", 4) == 0)
 275     smtp_dsn_set_ret (message, Ret_FULL);
 276 }
 277
 278 #if defined (USE_LIBESMTP) && (defined (USE_SSL) || defined (USE_GNUTLS))
 279 int mutt_libesmtp_check_usetls (const char* option, unsigned long p,
 280                                 char* errbuf, size_t errlen) {
 281   char* val = (char*) p;
 282   if (m_strisempty(val))
 283     return (1);
 284   if (m_strncmp(val, "enabled", 7) != 0 &&
 285       m_strncmp(val, "required", 8) != 0) {
 286     if (errbuf)
 287       snprintf (errbuf, errlen, _("'%s' is invalid for %s"), val, option);
 288     return (0);
 289   }
 290   return (1);
 291 }
 292 #endif
 293
 294 /*
 295  * mutt_libesmtp_invoke
 296  *   Sends a mail message to the provided recipients using libesmtp.
 297  *   Returns 0 upon success, -1 upon failure (and prints an error
 298  *   message).
 299  */
 300 int mutt_libesmtp_invoke (address_t * from,       /* the sender */
 301                           address_t * to, address_t * cc, address_t * bcc,    /* recips */
 302                           const char *msg,      /* file containing message */
 303                           int eightbit)
 304 {                               /* message contains 8bit chars */
 305   int ret = 0;                  /* return value, default = success */
 306   smtp_session_t session;
 307   smtp_message_t message;
 308   char *hostportstr = NULL;
 309   size_t hostportlen;
 310   FILE *fp = NULL;
 311   auth_context_t authctx = NULL;
 312   const smtp_status_t *status;
 313   char* envfrom = from->mailbox;
 314
 315   _mutt_libesmtp_ensure_init ();
 316
 317   if ((session = smtp_create_session ()) == NULL)
 318     SMTPFAIL ("smtp_create_session");
 319
 320 #if defined (USE_SSL) || (defined (USE_GNUTLS) && defined (HAVE_GNUTLS_OPENSSL_H))
 321   if (SmtpUseTLS != NULL && ascii_strncasecmp("enabled", SmtpUseTLS, 7) == 0) {
 322     smtp_starttls_enable(session, Starttls_ENABLED);
 323   } else if (SmtpUseTLS != NULL && ascii_strncasecmp("required", SmtpUseTLS, 8) == 0) {
 324     smtp_starttls_enable(session, Starttls_REQUIRED);
 325   }
 326 #endif
 327
 328   /* Create hostname:port string and tell libesmtp */
 329   /* len = SmtpHost len + colon + max port (65536 => 5 chars) + terminator */
 330   hostportlen = m_strlen(SmtpHost) + 7;
 331   hostportstr = p_new(char, hostportlen);
 332   snprintf (hostportstr, hostportlen, "%s:%d", SmtpHost, SmtpPort);
 333   if (!smtp_set_server (session, hostportstr))
 334     SMTPFAIL ("smtp_set_server");
 335
 336   if (SmtpAuthUser) {
 337     if ((authctx = auth_create_context ()) == NULL)
 338       MSGFAIL ("auth_create_context failed");
 339     auth_set_mechanism_flags (authctx, AUTH_PLUGIN_PLAIN, 0);
 340     auth_set_interact_cb (authctx, _mutt_libesmtp_auth_interact, NULL);
 341
 342     if (!smtp_auth_set_context (session, authctx))
 343       SMTPFAIL ("smtp_auth_set_context");
 344   }
 345
 346 #if defined (USE_SSL) || (defined (USE_GNUTLS) && defined (HAVE_GNUTLS_OPENSSL_H))
 347   smtp_starttls_set_ctx (session, NULL);
 348 #endif
 349   smtp_set_eventcb (session, event_cb, NULL);
 350
 351   if ((message = smtp_add_message (session)) == NULL)
 352     SMTPFAIL ("smtp_add_message");
 353
 354   /*  Initialize envelope sender */
 355   if (option (OPTENVFROM) && EnvFrom)
 356     envfrom = EnvFrom->mailbox;
 357   if (!smtp_set_reverse_path (message, envfrom))
 358     SMTPFAIL ("smtp_set_reverse_path");
 359
 360   /* set up DSN for message */
 361   do_dsn_notify (message, envfrom);
 362   do_dsn_ret (message);
 363
 364   /* set up 8bitmime flag */
 365   if (eightbit && option (OPTUSE8BITMIME))
 366     smtp_8bitmime_set_body (message, E8bitmime_8BITMIME);
 367
 368   if ((fp = fopen (msg, "r")) == NULL)
 369     LIBCFAIL ("fopen");
 370   if (!smtp_set_messagecb (message, _mutt_libesmtp_messagefp_cb, fp))
 371     SMTPFAIL ("smtp_set_messagecb");
 372   if (_mutt_libesmtp_add_recipients (message, to))
 373     FAIL ();
 374   if (_mutt_libesmtp_add_recipients (message, cc))
 375     FAIL ();
 376   if (_mutt_libesmtp_add_recipients (message, bcc))
 377     FAIL ();
 378   if (!smtp_start_session (session))
 379     SMTPFAIL ("smtp_start_session");
 380
 381   status = smtp_message_transfer_status (message);
 382   if (status->code < 200 || status->code > 299) {
 383     char buf[256];
 384
 385     snprintf (buf, sizeof (buf), "SMTP error while sending: %d %s",
 386               status->code, status->text);
 387     MSGFAIL (buf);
 388   }
 389
 390 Done:
 391   m_fclose(&fp);
 392   if (hostportstr != NULL)
 393     p_delete(&hostportstr);
 394   if (session != NULL)
 395     smtp_destroy_session (session);
 396   if (authctx != NULL)
 397     auth_destroy_context (authctx);
 398
 399   /* Forget user-entered SMTP AUTH password if send fails */
 400   if (ret != 0)
 401     authpass[0] = '\0';
 402
 403   return ret;
 404 }