mailx.c

Go to the documentation of this file.

#define _POSIX_C_SOURCE 200809L

#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "smtp.h"

struct mailx_address{
  enum smtp_address_type address_type;

  char email[1000];
};

struct mailx_attachment{
  char name[1000];

  char path[1000];
};

struct mailx{
  struct smtp *smtp;

  const char *subject;

  char *body;

  char *server;

  char *port;

  char *user;

  char *pass;

  char *from;

  enum smtp_connection_security connection_security;

  enum smtp_authentication_method auth_method;

  enum smtp_flag smtp_flags;

  struct mailx_address *address_list;

  size_t num_address;

  struct mailx_attachment *attachment_list;

  size_t num_attachment;
};

static char *
smtp_ffile_get_contents(FILE *stream,
                        size_t *bytes_read){
  char *read_buf;
  size_t bufsz;
  char *new_buf;
  const size_t BUFSZ_INCREMENT = 512;

  read_buf = NULL;
  bufsz = 0;

  if(bytes_read){
    *bytes_read = 0;
  }

  do{
    size_t bytes_read_loop;
    if((new_buf = realloc(read_buf, bufsz + BUFSZ_INCREMENT)) == NULL){
      free(read_buf);
      return NULL;
    }
    read_buf = new_buf;
    bufsz += BUFSZ_INCREMENT;

    bytes_read_loop = fread(&read_buf[bufsz - BUFSZ_INCREMENT],
                            sizeof(char),
                            BUFSZ_INCREMENT,
                            stream);
    if(bytes_read){
      *bytes_read += bytes_read_loop;
    }
    if(ferror(stream)){
      free(read_buf);
      return NULL;
    }
  } while(!feof(stream));

  return read_buf;
}

static void
mailx_address_append(struct mailx *const mailx,
                     enum smtp_address_type address_type,
                     const char *const email){
  struct mailx_address *new_address;
  size_t new_address_list_sz;

  mailx->num_address += 1;
  new_address_list_sz = mailx->num_address * sizeof(*mailx->address_list);
  if((mailx->address_list = realloc(mailx->address_list,
                                 new_address_list_sz)) == NULL){
    err(1, "realloc");
  }

  new_address = &mailx->address_list[mailx->num_address - 1];
  new_address->address_type = address_type;
  strncpy(new_address->email, email, sizeof(new_address->email));
  new_address->email[sizeof(new_address->email) - 1] = '\0';
}

static void
mailx_send(struct mailx *const mailx){
  int rc;
  size_t i;
  const struct mailx_address *address;
  const struct mailx_attachment *attachment;

  smtp_open(mailx->server,
            mailx->port,
            mailx->connection_security,
            mailx->smtp_flags,
            NULL,
            &mailx->smtp);

  smtp_auth(mailx->smtp,
            mailx->auth_method,
            mailx->user,
            mailx->pass);

  for(i = 0; i < mailx->num_address; i++){
    address = &mailx->address_list[i];
    smtp_address_add(mailx->smtp, address->address_type, address->email, NULL);
  }

  for(i = 0; i < mailx->num_attachment; i++){
    attachment = &mailx->attachment_list[i];
    smtp_attachment_add_path(mailx->smtp, attachment->name, attachment->path);
  }
  smtp_header_add(mailx->smtp, "Subject", mailx->subject);
  smtp_mail(mailx->smtp, mailx->body);

  rc = smtp_close(mailx->smtp);

  if(rc != SMTP_STATUS_OK){
    errx(1, "%s", smtp_status_code_errstr(rc));
  }
}

static void
mailx_append_attachment(struct mailx *const mailx,
                        const char *const filename,
                        const char *const path){
  struct mailx_attachment *new_attachment;
  size_t new_attachment_list_sz;

  if(filename == NULL || path == NULL){
    errx(1, "must provide attachment with valid name:path");
  }

  new_attachment_list_sz = (mailx->num_attachment + 1) *
                           sizeof(*mailx->attachment_list);
  if((mailx->attachment_list = realloc(mailx->attachment_list,
                                       new_attachment_list_sz)) == NULL){
    err(1, "realloc: attachment list");
  }
  new_attachment = &mailx->attachment_list[mailx->num_attachment];
  mailx->num_attachment += 1;

  strncpy(new_attachment->name, filename, sizeof(new_attachment->name));
  new_attachment->name[sizeof(new_attachment->name) - 1] = '\0';

  strncpy(new_attachment->path, path, sizeof(new_attachment->path));
  new_attachment->path[sizeof(new_attachment->path) - 1] = '\0';
}

static void
mailx_append_attachment_arg(struct mailx *const mailx,
                            const char *const attach_arg){
  char *attach_arg_dup;
  char *filename;
  char *filepath;

  if((attach_arg_dup = strdup(attach_arg)) == NULL){
    err(1, "strdup: %s", attach_arg);
  }

  filename = strtok(attach_arg_dup, ":");
  filepath = strtok(NULL, ":");

  mailx_append_attachment(mailx, filename, filepath);

  free(attach_arg_dup);
}

static void
mailx_parse_smtp_option(struct mailx *const mailx,
                        const char *const option){
  char *optdup;
  char *opt_key;
  char *opt_value;
  int rc;

  rc = 0;

  if((optdup = strdup(option)) == NULL){
    err(1, "strdup: option: %s", option);
  }

  if((opt_key = strtok(optdup, "=")) == NULL){
    errx(1, "strtok: %s", optdup);
  }

  opt_value = strtok(NULL, "=");

  if(strcmp(opt_key, "smtp-security") == 0){
    if(strcmp(opt_value, "none") == 0){
      mailx->connection_security = SMTP_SECURITY_NONE;
    }
#ifdef SMTP_OPENSSL
    else if(strcmp(opt_value, "tls") == 0){
      mailx->connection_security = SMTP_SECURITY_TLS;
    }
    else if(strcmp(opt_value, "starttls") == 0){
      mailx->connection_security = SMTP_SECURITY_STARTTLS;
    }
#endif /* SMTP_OPENSSL */
    else{
      rc = -1;
    }
  }
  else if(strcmp(opt_key, "smtp-auth") == 0){
    if(strcmp(opt_value, "none") == 0){
      mailx->auth_method = SMTP_AUTH_NONE;
    }
    else if(strcmp(opt_value, "plain") == 0){
      mailx->auth_method = SMTP_AUTH_PLAIN;
    }
    else if(strcmp(opt_value, "login") == 0){
      mailx->auth_method = SMTP_AUTH_LOGIN;
    }
#ifdef SMTP_OPENSSL
    else if(strcmp(opt_value, "cram-md5") == 0){
      mailx->auth_method = SMTP_AUTH_CRAM_MD5;
    }
#endif /* SMTP_OPENSSL */
    else{
      rc = -1;
    }
  }
  else if(strcmp(opt_key, "smtp-flag") == 0){
    if(strcmp(opt_value, "debug") == 0){
      mailx->smtp_flags |= SMTP_DEBUG;
    }
    else if(strcmp(opt_value, "no-cert-verify") == 0){
      mailx->smtp_flags |= SMTP_NO_CERT_VERIFY;
    }
    else{
      rc = -1;
    }
  }
  else if(strcmp(opt_key, "smtp-server") == 0){
    if((mailx->server = strdup(opt_value)) == NULL){
      err(1, "strdup");
    }
  }
  else if(strcmp(opt_key, "smtp-port") == 0){
    if((mailx->port = strdup(opt_value)) == NULL){
      err(1, "strdup");
    }
  }
  else if(strcmp(opt_key, "smtp-user") == 0){
    if((mailx->user = strdup(opt_value)) == NULL){
      err(1, "strdup");
    }
  }
  else if(strcmp(opt_key, "smtp-pass") == 0){
    if((mailx->pass = strdup(opt_value)) == NULL){
      err(1, "strdup");
    }
  }
  else if(strcmp(opt_key, "smtp-from") == 0){
    if((mailx->from = strdup(opt_value)) == NULL){
      err(1, "strdup");
    }
  }
  else{
    rc = -1;
  }

  free(optdup);

  if(rc < 0){
    errx(1, "invalid argument: %s", option);
  }
}

static void
mailx_init_default_values(struct mailx *const mailx){
  memset(mailx, 0, sizeof(*mailx));
  mailx->subject = "";
  mailx->connection_security = SMTP_SECURITY_NONE;
  mailx->auth_method = SMTP_AUTH_NONE;
}

static void
mailx_free(const struct mailx *const mailx){
  free(mailx->body);
  free(mailx->server);
  free(mailx->port);
  free(mailx->user);
  free(mailx->pass);
  free(mailx->from);
}

int main(int argc, char *argv[]){
  int rc;
  int i;
  struct mailx mailx;

  mailx_init_default_values(&mailx);

  while((rc = getopt(argc, argv, "a:s:S:")) != -1){
    switch(rc){
    case 'a':
      mailx_append_attachment_arg(&mailx, optarg);
      break;
    case 's':
      mailx.subject = optarg;
      break;
    case 'S':
      mailx_parse_smtp_option(&mailx, optarg);
      break;
    default:
      return 1;
    }
  }
  argc -= optind;
  argv += optind;

  if(argc < 1){
    errx(1, "must provide at least one email destination address");
  }

  if(mailx.from == NULL){
    errx(1, "must provide a FROM address");
  }

  if(mailx.server == NULL){
    if((mailx.server = strdup("localhost")) == NULL){
      err(1, "strdup");
    }
  }

  if(mailx.port == NULL){
    if((mailx.port = strdup("25")) == NULL){
      err(1, "strdup");
    }
  }

  puts("Reading email body from stdin");
  if((mailx.body = smtp_ffile_get_contents(stdin, NULL)) == NULL){
    err(1, "failed to read email body from stdin");
  }

  mailx_address_append(&mailx, SMTP_ADDRESS_FROM, mailx.from);

  for(i = 0; i < argc; i++){
    mailx_address_append(&mailx, SMTP_ADDRESS_TO, argv[i]);
  }

  mailx_send(&mailx);
  mailx_free(&mailx);
  return 0;
}