/* Copyright (c) 2002-2018 Dovecot authors, see the included COPYING file */

#include "lib.h"

#include "llist.h"

#include "str.h"

#include "strescape.h"

#include "smtp-address.h"

#include "message-parser.h"

#include "message-address.h"

#include "rfc822-parser.h"

struct message_address_parser_context {

  pool_t pool;

  struct rfc822_parser_context parser;

  struct message_address addr;

  struct message_address_list addr_list;

  string_t *str;

  bool fill_missing, non_strict_dots;

};

static void add_address(struct message_address_parser_context *ctx)

{

  struct message_address *addr;

  addr = p_new(ctx->pool, struct message_address, 1);

  memcpy(addr, &ctx->addr, sizeof(ctx->addr));

  i_zero(&ctx->addr);

  DLLIST2_APPEND(&ctx->addr_list.head, &ctx->addr_list.tail, addr);

}

/* quote with "" and escape all '\', '"' and "'" characters if need */

static void str_append_maybe_escape(string_t *dest, const char *cstr, bool escape_dot)

{

  const char *p;

  /* see if we need to quote it */

  for (p = cstr; *p != '\0'; p++) {

    if (!IS_ATEXT(*p) && (escape_dot || *p != '.'))

      break;

  }

  if (*p == '\0') {

    str_append_data(dest, cstr, (size_t) (p - cstr));

    return;

  }

  /* see if we need to escape it */

  for (p = cstr; *p != '\0'; p++) {

    if (IS_ESCAPED_CHAR(*p))

      break;

  }

  if (*p == '\0') {

    /* only quote */

    str_append_c(dest, '"');

    str_append_data(dest, cstr, (size_t) (p - cstr));

    str_append_c(dest, '"');

    return;

  }

  /* quote and escape */

  str_append_c(dest, '"');

  str_append_data(dest, cstr, (size_t) (p - cstr));

  for (; *p != '\0'; p++) {

    if (IS_ESCAPED_CHAR(*p))

      str_append_c(dest, '\\');

    str_append_c(dest, *p);

  }

  str_append_c(dest, '"');

}

static int

parse_nonstrict_dot_atom(struct rfc822_parser_context *ctx, string_t *str)

{

  int ret = -1;

  do {

    while (*ctx->data == '.') {

      str_append_c(str, '.');

      ctx->data++;

      if (ctx->data == ctx->end) {

        /* @domain is missing, but local-part

           parsing was successful */

        return 0;

      }

      ret = 1;

    }

    if (*ctx->data == '@')

      break;

    ret = rfc822_parse_atom(ctx, str);

  } while (ret > 0 && *ctx->data == '.');

  return ret;

}

static int parse_local_part(struct message_address_parser_context *ctx)

{

  int ret;

  /*

     local-part      = dot-atom / quoted-string / obs-local-part

     obs-local-part  = word *("." word)

  */

  i_assert(ctx->parser.data < ctx->parser.end);

  str_truncate(ctx->str, 0);

  if (*ctx->parser.data == '"')

    ret = rfc822_parse_quoted_string(&ctx->parser, ctx->str);

  else if (!ctx->non_strict_dots)

    ret = rfc822_parse_dot_atom(&ctx->parser, ctx->str);

  else

    ret = parse_nonstrict_dot_atom(&ctx->parser, ctx->str);

  if (ret < 0)

    return -1;

  ctx->addr.mailbox = p_strdup(ctx->pool, str_c(ctx->str));

  return ret;

}

static int parse_domain(struct message_address_parser_context *ctx)

{

  int ret;

  str_truncate(ctx->str, 0);

  if ((ret = rfc822_parse_domain(&ctx->parser, ctx->str)) < 0)

    return -1;

  ctx->addr.domain = p_strdup(ctx->pool, str_c(ctx->str));

  return ret;

}

static int parse_domain_list(struct message_address_parser_context *ctx)

{

  int ret;

  /* obs-domain-list = "@" domain *(*(CFWS / "," ) [CFWS] "@" domain) */

  str_truncate(ctx->str, 0);

  for (;;) {

    if (ctx->parser.data >= ctx->parser.end)

      return 0;

    if (*ctx->parser.data != '@')

      break;

    if (str_len(ctx->str) > 0)

      str_append_c(ctx->str, ',');

    str_append_c(ctx->str, '@');

    if ((ret = rfc822_parse_domain(&ctx->parser, ctx->str)) <= 0)

      return ret;

    while (rfc822_skip_lwsp(&ctx->parser) > 0 &&

           *ctx->parser.data == ',')

      ctx->parser.data++;

  }

  ctx->addr.route = p_strdup(ctx->pool, str_c(ctx->str));

  return 1;

}

static int parse_angle_addr(struct message_address_parser_context *ctx,

          bool parsing_path)

{

  /* "<" [ "@" route ":" ] local-part "@" domain ">" */

  i_assert(*ctx->parser.data == '<');

  ctx->parser.data++;

  if (rfc822_skip_lwsp(&ctx->parser) <= 0)

    return -1;

  if (*ctx->parser.data == '@') {

    if (parse_domain_list(ctx) > 0 && *ctx->parser.data == ':') {

      ctx->parser.data++;

    } else if (parsing_path && (ctx->parser.data >= ctx->parser.end || *ctx->parser.data != ':')) {

      return -1;

    } else {

      if (ctx->fill_missing)

        ctx->addr.route = "INVALID_ROUTE";

      if (ctx->parser.data >= ctx->parser.end)

        return -1;

      /* try to continue anyway */

    }

    if (rfc822_skip_lwsp(&ctx->parser) <= 0)

      return -1;

  }

  if (*ctx->parser.data == '>') {

    /* <> address isn't valid */

  } else {

    if (parse_local_part(ctx) <= 0)

      return -1;

    if (*ctx->parser.data == '@') {

      if (parse_domain(ctx) <= 0)

        return -1;

    }

  }

  if (*ctx->parser.data != '>')

    return -1;

  ctx->parser.data++;

  return rfc822_skip_lwsp(&ctx->parser);

}

static int parse_name_addr(struct message_address_parser_context *ctx)

{

  /*

     name-addr       = [display-name] angle-addr

     display-name    = phrase

  */

  str_truncate(ctx->str, 0);

  if (rfc822_parse_phrase(&ctx->parser, ctx->str) <= 0 ||

      *ctx->parser.data != '<')

    return -1;

  ctx->addr.name = p_strdup(ctx->pool, str_c(ctx->str));

  if (*ctx->addr.name == '\0') {

    /* Cope with "<address>" without display name */

    ctx->addr.name = NULL;

  }

  if (parse_angle_addr(ctx, FALSE) < 0) {

    /* broken */

    if (ctx->fill_missing)

      ctx->addr.domain = "SYNTAX_ERROR";

    ctx->addr.invalid_syntax = TRUE;

  }

  return ctx->parser.data < ctx->parser.end ? 1 : 0;

}

static int parse_addr_spec(struct message_address_parser_context *ctx)

{

  /* addr-spec       = local-part "@" domain */

  int ret, ret2 = -2;

  i_assert(ctx->parser.data < ctx->parser.end);

  str_truncate(ctx->parser.last_comment, 0);

  bool quoted_string = *ctx->parser.data == '"';

  ret = parse_local_part(ctx);

  if (ret <= 0) {

    /* end of input or parsing local-part failed */

    ctx->addr.invalid_syntax = TRUE;

  }

  if (ret != 0 && ctx->parser.data < ctx->parser.end &&

      *ctx->parser.data == '@') {

    ret2 = parse_domain(ctx);

    if (ret2 <= 0)

      ret = ret2;

  }

  if (str_len(ctx->parser.last_comment) > 0)

    ctx->addr.name = p_strdup(ctx->pool, str_c(ctx->parser.last_comment));

  else if (ret2 == -2) {

    /* So far we've read user without @domain and without

       (Display Name). We'll assume that a single "user" (already

       read into addr.mailbox) is a mailbox, but if it's followed

       by anything else it's a display-name. */

    str_append_c(ctx->str, ' ');

    size_t orig_str_len = str_len(ctx->str);

    (void)rfc822_parse_phrase(&ctx->parser, ctx->str);

    if (str_len(ctx->str) != orig_str_len) {

      ctx->addr.mailbox = NULL;

      ctx->addr.name = p_strdup(ctx->pool, str_c(ctx->str));

    } else {

      if (!quoted_string)

        ctx->addr.domain = "";

    }

    ctx->addr.invalid_syntax = TRUE;

    ret = -1;

  }

  return ret;

}

static void add_fixed_address(struct message_address_parser_context *ctx)

{

  if (ctx->addr.mailbox == NULL) {

    ctx->addr.mailbox = !ctx->fill_missing ? "" : "MISSING_MAILBOX";

    ctx->addr.invalid_syntax = TRUE;

  }

  if (ctx->addr.domain == NULL || ctx->addr.domain[0] == '\0') {

    ctx->addr.domain = !ctx->fill_missing ? "" : "MISSING_DOMAIN";

    ctx->addr.invalid_syntax = TRUE;

  }

  add_address(ctx);

}

static int parse_mailbox(struct message_address_parser_context *ctx)

{

  const unsigned char *start;

  int ret;

  /* mailbox         = name-addr / addr-spec */

  start = ctx->parser.data;

  if ((ret = parse_name_addr(ctx)) < 0) {

    /* nope, should be addr-spec */

    ctx->parser.data = start;

    ret = parse_addr_spec(ctx);

    if (ctx->addr.invalid_syntax && ctx->addr.name == NULL &&

        ctx->addr.mailbox != NULL && ctx->addr.domain == NULL) {

      ctx->addr.name = ctx->addr.mailbox;

      ctx->addr.mailbox = NULL;

    }

  }

  if (ret < 0)

    ctx->addr.invalid_syntax = TRUE;

  add_fixed_address(ctx);

  return ret;

}

static int parse_group(struct message_address_parser_context *ctx)

{

  int ret;

  /*

     group           = display-name ":" [mailbox-list / CFWS] ";" [CFWS]

     display-name    = phrase

  */

  str_truncate(ctx->str, 0);

  if (rfc822_parse_phrase(&ctx->parser, ctx->str) <= 0 ||

      *ctx->parser.data != ':')

    return -1;

  /* from now on don't return -1 even if there are problems, so that

     the caller knows this is a group */

  ctx->parser.data++;

  if ((ret = rfc822_skip_lwsp(&ctx->parser)) <= 0)

    ctx->addr.invalid_syntax = TRUE;

  ctx->addr.mailbox = p_strdup(ctx->pool, str_c(ctx->str));

  add_address(ctx);

  if (ret > 0 && *ctx->parser.data != ';') {

    for (;;) {

      /* mailbox-list    =

          (mailbox *("," mailbox)) / obs-mbox-list */

      if (parse_mailbox(ctx) <= 0) {

        /* broken mailbox - try to continue anyway. */

      }

      if (ctx->parser.data >= ctx->parser.end ||

          *ctx->parser.data != ',')

        break;

      ctx->parser.data++;

      if (rfc822_skip_lwsp(&ctx->parser) <= 0) {

        ret = -1;

        break;

      }

    }

  }

  if (ret >= 0) {

    if (ctx->parser.data >= ctx->parser.end ||

        *ctx->parser.data != ';')

      ret = -1;

    else {

      ctx->parser.data++;

      ret = rfc822_skip_lwsp(&ctx->parser);

    }

  }

  if (ret < 0)

    ctx->addr.invalid_syntax = TRUE;

  add_address(ctx);

  return ret == 0 ? 0 : 1;

}

static int parse_address(struct message_address_parser_context *ctx)

{

  const unsigned char *start;

  int ret;

  /* address         = mailbox / group */

  start = ctx->parser.data;

  if ((ret = parse_group(ctx)) < 0) {

    /* not a group, try mailbox */

    ctx->parser.data = start;

    ret = parse_mailbox(ctx);

  }

  return ret;

}

static int parse_address_list(struct message_address_parser_context *ctx,

            unsigned int max_addresses)

{

  int ret = 0;

  /* address-list    = (address *("," address)) / obs-addr-list */

  while (max_addresses > 0) {

    max_addresses--;

    if ((ret = parse_address(ctx)) == 0)

      break;

    if (ctx->parser.data >= ctx->parser.end ||

        *ctx->parser.data != ',') {

      ret = -1;

      break;

    }

    ctx->parser.data++;

    if ((ret = rfc822_skip_lwsp(&ctx->parser)) <= 0) {

      if (ret < 0) {

        /* ends with some garbage */

        add_fixed_address(ctx);

      }

      break;

    }

  }

  return ret;

}

static int parse_path(struct message_address_parser_context *ctx)

{

  int ret;

  if (rfc822_skip_lwsp(&ctx->parser) <= 0)

    return -1;

  if (*ctx->parser.data != '<') {

    /* Cope with paths that omit < and >. This is a syntax

       violation, but we allow it to account for a rather wide

       selection of software that does not follow the standards.

     */

    if ((ret=parse_local_part(ctx)) > 0 &&

        *ctx->parser.data == '@') {

      ret = parse_domain(ctx);

    }

  } else {

    ret = parse_angle_addr(ctx, TRUE);

  }

  if (ret < 0 || (ret=rfc822_skip_lwsp(&ctx->parser)) < 0 ||

      ctx->parser.data != ctx->parser.end ||

      (ctx->addr.mailbox != NULL &&

       (ctx->addr.domain == NULL || *ctx->addr.domain == '\0')) ||

      (ctx->addr.mailbox == NULL && ctx->addr.domain != NULL)) {

    ctx->addr.invalid_syntax = TRUE;

    ret = -1;

  }

  add_address(ctx);

  return ret;

}

static void

message_address_parse_real(pool_t pool, const unsigned char *data, size_t size,

         unsigned int max_addresses,

         enum message_address_parse_flags flags,

         struct message_address_list *list_r)

{

  struct message_address_parser_context ctx;

  i_zero(&ctx);

  rfc822_parser_init(&ctx.parser, data, size, t_str_new(128));

  ctx.parser.nul_replacement_str = RFC822_NUL_REPLACEMENT_STR;

  ctx.pool = pool;

  ctx.str = str_new(default_pool, 128);

  ctx.fill_missing = (flags & MESSAGE_ADDRESS_PARSE_FLAG_FILL_MISSING) != 0;

  ctx.non_strict_dots = (flags & MESSAGE_ADDRESS_PARSE_FLAG_STRICT_DOTS) == 0;

  if (rfc822_skip_lwsp(&ctx.parser) <= 0) {

    /* no addresses */

  } else {

    (void)parse_address_list(&ctx, max_addresses);

  }

  rfc822_parser_deinit(&ctx.parser);

  str_free(&ctx.str);

  *list_r = ctx.addr_list;

}

static int

message_address_parse_path_real(pool_t pool, const unsigned char *data,

        size_t size, struct message_address **addr_r)

{

  struct message_address_parser_context ctx;

  int ret;

  i_zero(&ctx);

  *addr_r = NULL;

  rfc822_parser_init(&ctx.parser, data, size, NULL);

  ctx.pool = pool;

  ctx.str = str_new(default_pool, 128);

  ret = parse_path(&ctx);

  rfc822_parser_deinit(&ctx.parser);

  str_free(&ctx.str);

  *addr_r = ctx.addr_list.head;

  return (ret < 0 ? -1 : 0);

}

struct message_address *

message_address_parse(pool_t pool, const unsigned char *data, size_t size,

          unsigned int max_addresses,

          enum message_address_parse_flags flags)

{

  struct message_address_list list;

  message_address_parse_full(pool, data, size, max_addresses, flags,

           &list);

  return list.head;

}

void message_address_parse_full(pool_t pool, const unsigned char *data,

        size_t size, unsigned int max_addresses,

        enum message_address_parse_flags flags,

        struct message_address_list *list_r)

{

  if (pool->datastack_pool) {

    message_address_parse_real(pool, data, size,

             max_addresses, flags, list_r);

  } else T_BEGIN {

    message_address_parse_real(pool, data, size,

             max_addresses, flags, list_r);

  } T_END;

}

int message_address_parse_path(pool_t pool, const unsigned char *data,

             size_t size, struct message_address **addr_r)

{

  int ret;

  if (pool->datastack_pool) {

    return message_address_parse_path_real(pool, data, size, addr_r);

  }

  T_BEGIN {

    ret = message_address_parse_path_real(pool, data, size, addr_r);

  } T_END;

  return ret;

}

void message_address_write(string_t *str, const struct message_address *addr)

{

  const char *tmp;

  bool first = TRUE, in_group = FALSE;

  if (addr == NULL)

    return;

  /* <> path */

  if (addr->mailbox == NULL && addr->domain == NULL) {

    i_assert(addr->next == NULL);

    str_append(str, "<>");

    return;

  }

  /* a) mailbox@domain

     b) name <@route:mailbox@domain>

     c) group: .. ; */

  while (addr != NULL) {

    if (first)

      first = FALSE;

    else

      str_append(str, ", ");

    if (addr->domain == NULL) {

      if (!in_group) {

        /* beginning of group. mailbox is the group

           name, others are NULL. */

        if (addr->mailbox != NULL && *addr->mailbox != '\0') {

          /* check for MIME encoded-word */

          if (strstr(addr->mailbox, "=?") != NULL)

            /* MIME encoded-word MUST NOT appear within a 'quoted-string'

               so escaping and quoting of phrase is not possible, instead

               use obsolete RFC822 phrase syntax which allow spaces */

            str_append(str, addr->mailbox);

          else

            str_append_maybe_escape(str, addr->mailbox, TRUE);

        } else {

          /* empty group name needs to be quoted */

          str_append(str, "\"\"");

        }

        str_append(str, ": ");

        first = TRUE;

      } else {

        /* end of group. all fields should be NULL. */

        i_assert(addr->mailbox == NULL);

        /* cut out the ", " */

        tmp = str_c(str)+str_len(str)-2;

        i_assert((tmp[0] == ',' || tmp[0] == ':') && tmp[1] == ' ');

        if (tmp[0] == ',' && tmp[1] == ' ')

          str_truncate(str, str_len(str)-2);

        else if (tmp[0] == ':' && tmp[1] == ' ')

          str_truncate(str, str_len(str)-1);

        str_append_c(str, ';');

      }

      in_group = !in_group;

    } else {

      /* "Display Name" <mailbox@domain> */

      i_assert(addr->mailbox != NULL);

      if (addr->name != NULL) {

        /* check for MIME encoded-word */

        if (strstr(addr->name, "=?") != NULL)

          /* MIME encoded-word MUST NOT appear within a 'quoted-string'

             so escaping and quoting of phrase is not possible, instead

             use obsolete RFC822 phrase syntax which allow spaces */

          str_append(str, addr->name);

        else

          str_append_maybe_escape(str, addr->name, TRUE);

      }

      if (addr->route != NULL ||

          addr->mailbox[0] != '\0' ||

          addr->domain[0] != '\0') {

        if (addr->name != NULL && addr->name[0] != '\0')

          str_append_c(str, ' ');

        str_append_c(str, '<');

        if (addr->route != NULL) {

          str_append(str, addr->route);

          str_append_c(str, ':');

        }

        if (addr->mailbox[0] == '\0')

          str_append(str, "\"\"");

        else

          str_append_maybe_escape(str, addr->mailbox, FALSE);

        if (addr->domain[0] != '\0') {

          str_append_c(str, '@');

          str_append(str, addr->domain);

        }

        str_append_c(str, '>');

      }

    }

    addr = addr->next;

  }

}

const char *message_address_to_string(const struct message_address *addr)

{

  string_t *str = t_str_new(256);

  message_address_write(str, addr);

  return str_c(str);

}

const char *message_address_first_to_string(const struct message_address *addr)

{

  struct message_address first_addr;

  first_addr = *addr;

  first_addr.prev = NULL;

  first_addr.next = NULL;

  first_addr.route = NULL;

  return message_address_to_string(&first_addr);

}

void message_address_init(struct message_address *addr,

  const char *name, const char *mailbox, const char *domain)

{

  i_zero(addr);

  addr->name = name;

  addr->mailbox = mailbox;

  addr->domain = domain;

}

void message_address_init_from_smtp(struct message_address *addr,

  const char *name, const struct smtp_address *smtp_addr)

{

  i_zero(addr);

  addr->name = name;

  addr->mailbox = smtp_addr->localpart;

  addr->domain = smtp_addr->domain;

}

static const char *address_headers[] = {

  "From", "Sender", "Reply-To",

  "To", "Cc", "Bcc",

  "Resent-From", "Resent-Sender", "Resent-To", "Resent-Cc", "Resent-Bcc"

};

bool message_header_is_address(const char *hdr_name)

{

  unsigned int i;

  for (i = 0; i < N_ELEMENTS(address_headers); i++) {

    if (strcasecmp(hdr_name, address_headers[i]) == 0)

      return TRUE;

  }

  return FALSE;

}