smtp_client.cpp

Go to the documentation of this file.

#ifndef SMTP_CLIENT_IMPLEMENTATION_FILE
#define SMTP_CLIENT_IMPLEMENTATION_FILE

/*****************************************************************************\
*                                                                             *
*  Name   : smtp_client                                                       *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2006-$now By Author.  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 is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "smtp_client.h"

#include <basis/function.h>
#include <basis/istring.h>
#include <basis/log_base.h>
#include <basis/mutex.h>
#include <basis/portable.h>
#include <basis/string_array.h>
#include <data_struct/static_memory_gremlin.h>
#include <mechanisms/time_stamp.h>
#include <opsystem/byte_filer.h>
#include <loggers/console_logger.h>
#include <opsystem/path_configuration.h>
#include <opsystem/redirecter.h>
#include <opsystem/registry_config.h>

#ifdef __WIN32__
  #include <atlenc.h>
#endif

#ifndef OMIT_PROGRAM_WIDE_LOGGER
  #define LOG(s) CLASS_EMERGENCY_LOG((_logging? *_logging \
      : program_wide_logger()), s)
#else
  #define LOG(s) CLASS_EMERGENCY_LOG(console_logger(), s)
#endif

#define CHECK_STILL_RUNNING(to_return) \
  if (!msmtp.running()) { \
    /* for some reason, it has departed. */ \
    LOG("the msmtp application already exited."); \
    if (!okay_exit_value(msmtp.exit_value())) return to_return; \
    else return OKAY; \
  }

const int MAXIMUM_WRITE_ITERATIONS = 40;
  // we won't try to write the message body forever, but we will try this
  // many times to get it all into the email.

const int MAXIMUM_PAUSE_FOR_SENDING = 30 * SECOND_ms;
  // we will allow the mail program to take this long to deal with the
  // email and exit.

const int DEFAULT_TIMEOUT = 0;
  // the default is to never timeout, rather than zero timeout.

smtp_client::smtp_client()
: _logging(NIL),
  _sess_server(new istring),
  _sess_port(SC_SMTP_DEFAULT_PORT),
  _sess_user(new istring),
  _sess_password(new istring),
  _msg_sender(new istring),
  _msg_subject(new istring),
  _msg_body(new istring),
  _msg_attachments(new string_array),
  _msg_recipients(new string_array),
  _msg_carbons(new string_array),
  _timeout(DEFAULT_TIMEOUT)
{}

smtp_client::smtp_client(log_base &logging)
: _logging(&logging),
  _sess_server(new istring),
  _sess_port(SC_SMTP_DEFAULT_PORT),
  _sess_user(new istring),
  _sess_password(new istring),
  _msg_sender(new istring),
  _msg_subject(new istring),
  _msg_body(new istring),
  _msg_attachments(new string_array),
  _msg_recipients(new string_array),
  _msg_carbons(new string_array),
  _timeout(DEFAULT_TIMEOUT)
{}

smtp_client::~smtp_client()
{
  WHACK(_sess_server);
  WHACK(_sess_user);
  WHACK(_sess_password);
  WHACK(_msg_sender);
  WHACK(_msg_subject);
  WHACK(_msg_body);
  WHACK(_msg_attachments);
  WHACK(_msg_recipients);
  WHACK(_msg_carbons);
}

const char *smtp_client::outcome_name(const outcome &to_name)
{ return communication_commons::outcome_name(to_name); }

void smtp_client::setup_session(const istring &server_name,
    int smtp_port, const istring &user_name, const istring &password)
{
  FUNCDEF("setup_session");
  set_server(server_name);
  set_port(smtp_port);
  set_auth_user(user_name);
  set_auth_password(password);

#ifdef __WIN32__
  // we must write the .netrc file on windows because the msmtp app is not
  // reading from normal stdin.  instead, it insists on ignoring stdin and
  // reading from the windows console input buffer.  that handle for the
  // console input seems to not be inheritable unless your launching app
  // is also console mode, which we totally cannot depend on.  thus we
  // resort to this lame approach.
  registry_configurator reg(registry_configurator::hkey_current_user,
      registry_configurator::RETURN_ONLY);

  istring temp_home = reg.load("Software\\Microsoft\\Windows\\CurrentVersion"
      "\\Explorer\\User Shell Folders", "AppData", "");
//LOG(istring("original home location is \"") + temp_home + "\"");
  if (!temp_home) {
    // assume we are operating as the system service.  this is not a great
    // assumption, but it does seem like we never get a path for the
    // system account.
    temp_home = "C:/Documents and Settings/LocalService/Application Data";
  }

//LOG(istring("home location is ") + temp_home);

  istring password_line("machine ");
  password_line += *_sess_server;
  password_line += " login ";
  password_line += *_sess_user;

  istring line_to_seek = password_line;
    // this part of the line forms a pattern we need to remove if it's
    // already in the file.

  password_line += " password ";
  password_line += *_sess_password;
  password_line += log_base::platform_ending();
  byte_filer netrc(temp_home + "/netrc.txt", "r");
  istring full_file;
  // read the current version of the file now.
  while (!netrc.eof()) {
const int MAX_LINE = 1000;
    istring line_read;
    int chars_read = netrc.getline(line_read, MAX_LINE);
    if (chars_read) {
      if (line_read.contains(line_to_seek)) continue;
        // skip the previous version of the password line.
      full_file += line_read;
    }
  }
  netrc.close();
  netrc.open(temp_home + "/netrc.txt", "w");
  full_file += password_line;  // add new line to the contents.
  // stream file back out, minus line with prefix we are seeking, plus
  // the new password setting.
  netrc.write(full_file);
//LOG(istring("wrote file ") + netrc.filename());
  netrc.close();
#endif
}

void smtp_client::set_server(const istring &server_name)
{ *_sess_server = server_name; }

void smtp_client::set_port(int smtp_port) { _sess_port = smtp_port; }

void smtp_client::set_auth_user(const istring &user_name)
{ *_sess_user = user_name; }

void smtp_client::set_auth_password(const istring &password)
{ *_sess_password = password; }

void smtp_client::setup_message(const istring &sender_email,
    const istring &subject, const istring &message_body,
    const istring &one_recipient)
{
  set_sender(sender_email);
  set_subject(subject);
  set_body(message_body);
  clear_recipients();
  add_recipient(one_recipient);
  clear_carbons();
}

void smtp_client::add_recipient(const istring &recipient)
{
  if (!recipient) return;
  *_msg_recipients += recipient;
}

bool smtp_client::remove_recipient(const istring &recipient)
{
  if (!recipient) return false;
  bool found_one = false;
  for (int i = 0; i < _msg_recipients->length(); i++) {
    // try to find the filename in the list.
    if (_msg_recipients->get(i) == recipient) {
      // found it; now whack it.
      _msg_recipients->zap(i, i);
      i--;  // skip the loop one back for what we just removed.
      found_one = true;
    }
  }
  return found_one;
}

void smtp_client::clear_recipients()
{
  _msg_recipients->reset();
}

void smtp_client::add_carbon(const istring &carbon)
{
  if (!carbon) return;
  *_msg_carbons += carbon;
}

bool smtp_client::remove_carbon(const istring &carbon)
{
  if (!carbon) return false;
  bool found_one = false;
  for (int i = 0; i < _msg_carbons->length(); i++) {
    // try to find the filename in the list.
    if (_msg_carbons->get(i) == carbon) {
      // found it; now whack it.
      _msg_carbons->zap(i, i);
      i--;  // skip the loop one back for what we just removed.
      found_one = true;
    }
  }
  return found_one;
}

void smtp_client::clear_carbons()
{
  _msg_carbons->reset();
}

void smtp_client::set_sender(const istring &sender_email)
{
  *_msg_sender = sender_email;
}

void smtp_client::set_subject(const istring &subject)
{
#ifdef __WIN32__
  // If there are any extended characters, then encode the subject
  // using "Q" encoding as defined in RFC 2047.
  if (GetExtendedChars(subject.s(), subject.length()) > 0)
  {
    int bufSize= QEncodeGetRequiredLength(subject.length(),
        ATL_MAX_ENC_CHARSET_LENGTH);
    istring encodedSubject;
    encodedSubject.pad(bufSize);
    QEncode((BYTE *)(subject.s()), subject.length(),
        encodedSubject.access(), &bufSize, "iso-8859-1");
    *_msg_subject = encodedSubject;
  }
  else
  {
    *_msg_subject = subject;
  }
#else
  *_msg_subject = subject;
#endif
}

void smtp_client::set_body(const istring &message_body)
{
#ifdef __WIN32__
  // encode the message body as "quoted-printable" as
  // defined in RFC 2045.  This will handle long lines and
  // any extended characters.
  int bufSize= QPEncodeGetRequiredLength(message_body.length());
  istring encodedBody;
  encodedBody.pad(bufSize);
  QPEncode((BYTE *)(message_body.s()), message_body.length(),
      encodedBody.access(), &bufSize);
  *_msg_body = encodedBody;
#else
  *_msg_body = message_body;
#endif
}

void smtp_client::set_timeout(int timeout)
{
  _timeout = timeout;
}

/*
void smtp_client::add_attachment(const istring &filename)
{
  if (!filename) return;
  *_msg_attachments += filename;
}

bool smtp_client::remove_attachment(const istring &filename)
{
  if (!filename) return false;
  bool found_one = false;
  for (int i = 0; i < _msg_attachments->length(); i++) {
    // try to find the filename in the list.
    if (_msg_attachments->get(i) == filename) {
      // found it; now whack it.
      _msg_attachments->zap(i, i);
      i--;  // skip the loop one back for what we just removed.
      found_one = true;
    }
  }
  return found_one;
}

void smtp_client::clear_attachments() { _msg_attachments->reset(); }

*/

bool smtp_client::get_outputs(stdio_redirecter &msmtp, byte_array &feedback)
{
  FUNCDEF("get_outputs");
  bool to_return = false;
  feedback.reset();
  outcome read_ret = msmtp.read(feedback);
  if (read_ret == stdio_redirecter::OKAY) {
    LOG(istring("out|") + istring(istring::UNTERMINATED,
        (char *)feedback.observe(), feedback.length()));
    to_return = true;
  }
  byte_array err_data;
  read_ret = msmtp.read_stderr(err_data);
  if (read_ret == stdio_redirecter::OKAY) {
    LOG(istring("err|") + istring(istring::UNTERMINATED,
        (char *)err_data.observe(), err_data.length()));
    feedback += err_data;
    to_return = true;
  }
  return to_return;
}

bool smtp_client::validate_address(const istring &to_check)
{
  istring name_portion;
  istring email_addr = prune_address(to_check, name_portion);
  int indy = email_addr.find('@');
  if (non_positive(indy)) return false;
    // can't be missing an @ (negative return) and can't have the @ as the
    // first part (zero return).
  if (email_addr.length() - 1 == indy) return false;
    // can't be hiding the @ sign at the end of the string with no other text.
  int indy2 = email_addr.find('@', indy + 1);
  if (non_negative(indy2)) return false;
    // we can't have two @'s in a single email address.

//hmmm: what about validating the actual textual characters of the address?
//      what are the smtp constraints on those characters?
// according to wikipedia, the constraints are:
// According to RFC 2822, the local-part of the e-mail may use any of these ASCII characters:
// Uppercase and lowercase letters (case insensitive)
// The digits 0 through 9
// The characters, ! # $ % & ' * + - / = ? ^ _ ` { | } ~
// The character "." provided that it is not the first or last character in the local-part.
//

  return true;
    // after all that, it's supposedly a tasty address.
}

istring smtp_client::prune_address(const istring &to_prune, istring &name)
{
  name = "";
  istring pruned_sender = to_prune;
  int indy = pruned_sender.find("<");
  if (non_negative(indy)) {
    name = pruned_sender.substring(0, indy - 1);
    pruned_sender.zap(0, indy);
  }
  indy = pruned_sender.find(">");
  if (non_negative(indy)) {
    pruned_sender.zap(indy, pruned_sender.end());
  }
  return pruned_sender;
}

bool smtp_client::okay_exit_value(int value) { return value == 0; }

#define CHECK_FOR_PASSWORD_PROMPT(bytes) { \
  istring text_gotten(istring::UNTERMINATED, (char *)bytes.observe(), \
      bytes.length()); \
  if (text_gotten.contains("password")) { \
    LOG("saw a password reference in the output; we may be missing " \
        "the password."); \
    msmtp.zap_program(); \
    return ACCESS_DENIED; \
  } \
  CHECK_STILL_RUNNING(BAD_INPUT); \
}

outcome smtp_client::send_email()
{
  FUNCDEF("send_email");
  // set up the path to the msmtp application.
  istring msmtp_path = path_configuration::application_directory() + "/msmtp";
#ifdef __WIN32__
  msmtp_path += ".exe";
#endif

  istring text_name;
  istring pruned_sender = prune_address(*_msg_sender, text_name);

  // start accumulating command line parameters for it.
  isprintf smtp_parms("--protocol=smtp --host %s --port %d --from=%s",
      _sess_server->s(), _sess_port, pruned_sender.s());
//LOG(istring("pruned sender: ") + pruned_sender);

  if (_timeout) {
    // the timeout was specified, so we enable it.  otherwise we expect the
    // default to be off, where it never times out.
    smtp_parms += isprintf(" --timeout=%d", _timeout / SECOND_ms);
  }

  // decide whether the session is to be authenticated or not.
  bool authenticating = false;
  if (_sess_user->t()) {
    authenticating = true;
    smtp_parms += " --auth=on";
    smtp_parms += isprintf(" --user=%s", _sess_user->s());
  }

  // add the recipients in now that all the other flags are done with.
  smtp_parms += " -- ";
  for (int i = 0; i < _msg_recipients->length(); i++) {
    istring name;
    istring just_addr = prune_address(_msg_recipients->get(i), name);
    smtp_parms += just_addr;
    smtp_parms += " ";
  }

  for (int i = 0; i < _msg_carbons->length(); i++) {
    istring name;
    istring just_addr = prune_address(_msg_carbons->get(i), name);
    smtp_parms += just_addr;
    smtp_parms += " ";
  }

//LOG(istring("about to run: ") + msmtp_path);
//LOG(istring("with parms: ") + smtp_parms);

  stdio_redirecter msmtp(msmtp_path, smtp_parms);
  if (msmtp.health() != stdio_redirecter::OKAY) {
    // that didn't work.
    LOG("failure to launch the msmtp application with redirected I/O.");
    return BAD_INPUT;  // we're calling this a configuration problem.
  }
  if (!msmtp.running()) {
    // somehow it launched but exited already?
    LOG("the msmtp application has unexpectedly left the process list.");
    return BAD_INPUT;  // we're calling this a configuration problem.
  }

  if (authenticating) {
    // expect the first thing it says to be a password prompt.

// not for windows, since we do the temporary config file instead.
// the windows version of msmtp will not allow us to feed the password over
// standard out since it puts the app into some kind of console only mode
// where nothing but real keypresses seem to be sufficient.
#ifndef __WIN32__
//hmmm: fix this to use timeout as defined in interface.
const int SOME_TIMEOUT = 30 * SECOND_ms;

    // wait until we see the prompt or suffer a timeout.
    time_stamp done_waiting(SOME_TIMEOUT);
    byte_array received;
    bool gave_password = false;
    while (time_stamp() < done_waiting) {
      byte_array temp;
      // add any new text to our input buffer.
      if (get_outputs(msmtp, temp)) {
        received += temp;
        // turn the bytes into a string for checking.
        istring text_gotten(istring::UNTERMINATED, (char *)received.observe(),
            received.length());
        if (text_gotten.contains("password")) {
          // we saw our keyword.  hopefully we got everything that we
          // needed to before sending this.
          int written;
          msmtp.write(*_sess_password + log_base::platform_ending(), written);
          gave_password = true;
//          LOG("wrote password to smtp app.");
          break;  // get out of loop.
        }
      }
      portable::sleep_ms(40);  // snooze a sec.
    }
    if (!gave_password) {
      LOG("never received password prompt for authenticated smtp.");
      return TIMED_OUT;  // some kind of problem with the server or config.
    }
#endif
  }

  CHECK_STILL_RUNNING(BAD_INPUT);
  byte_array junk;
  get_outputs(msmtp, junk);
  CHECK_FOR_PASSWORD_PROMPT(junk);

  int len_written = 0;  // used in writing to the smtp app.

#ifdef __WIN32__
  // Add some standard headers to specify how we will be encoding
  // the message body
  istring header_lines = "MIME-Version: 1.0";
  header_lines += log_base::platform_ending();
  header_lines += "Content-Type: text/plain; charset=\"iso-8859-1\"";
  header_lines += log_base::platform_ending();
  header_lines += "Content-Transfer-Encoding: quoted-printable";
  header_lines += log_base::platform_ending();
  msmtp.write(header_lines, len_written);
#endif

  istring subject_line = "Subject: ";
  subject_line += *_msg_subject; 
  subject_line += log_base::platform_ending();
  msmtp.write(subject_line, len_written);
    // we're not super concerned about the subject being too long to write
    // all of it at once.  if they passed a huge multi-megabyte subject line,
    // then they can just reap it.
//LOG(istring("wrote ") + subject_line);

  // create the full-fledged from address now.
  istring from_address = "From: ";
  from_address += *_msg_sender;
  from_address += log_base::platform_ending();
  msmtp.write(from_address, len_written);
    // not super concerned about overly long from addresses either.
//LOG(istring("wrote ") + from_address);

  // add the nicely formatted destination addresses.
  for (int i = 0; i < _msg_recipients->length(); i++) {
    istring to_line = "To: ";
    to_line += _msg_recipients->get(i);
    to_line += log_base::platform_ending();
    msmtp.write(to_line, len_written);
//LOG(istring("wrote ") + to_line);
  }

  // add some CC addresses also, if any exist.
  for (int i = 0; i < _msg_carbons->length(); i++) {
    istring to_line = "CC: ";
    to_line += _msg_carbons->get(i);
    to_line += log_base::platform_ending();
    msmtp.write(to_line, len_written);
//LOG(istring("wrote ") + to_line);
  }

  // end the headers with a blank line.
  msmtp.write(log_base::platform_ending(), len_written);

  get_outputs(msmtp, junk);
  CHECK_FOR_PASSWORD_PROMPT(junk);

  int writing = _msg_body->length();
  int maximum_iters = MAXIMUM_WRITE_ITERATIONS;
    // don't languish forever if the writes aren't working.
  while ( (writing > 0) && (maximum_iters-- > 0) ) {
    CHECK_STILL_RUNNING(BAD_INPUT);
    msmtp.write(*_msg_body, len_written);
    writing -= len_written;
    // prune the string if we need to try some more to write it all.
    if (writing)
      _msg_body->zap(0, len_written - 1);
  }
  msmtp.write(log_base::platform_ending(), len_written);
//LOG(istring("wrote body: ") + *_msg_body);

//hmmm: eventually--encode attachments and dump them in also.

  get_outputs(msmtp, junk);
  CHECK_FOR_PASSWORD_PROMPT(junk);

  msmtp.close_input();
  time_stamp when_to_leave(MAXIMUM_PAUSE_FOR_SENDING);
  while ( (time_stamp() < when_to_leave) && msmtp.running() ) {
    portable::sleep_ms(42);  // pause a bit.
  }
  if (time_stamp() > when_to_leave) return TIMED_OUT;

  get_outputs(msmtp, junk);
    // last check for pending i/o.

  // check the exit value to make sure things look okay.
  if (!okay_exit_value(msmtp.exit_value())) return BAD_INPUT;

  return OKAY;
}


#endif //SMTP_CLIENT_IMPLEMENTATION_FILE

---