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

#include "lib.h"

#include "str.h"

#include "strescape.h"

const char *str_nescape(const void *str, size_t len)

{

  string_t *dest = t_str_new(len*2);

  str_append_escaped(dest, str, len);

  return str_c(dest);

}

void str_append_escaped(string_t *dest, const void *src, size_t src_size)

{

  const unsigned char *pstart = src, *p = src, *pend = pstart + src_size;

  /* see if we need to quote it */

  for (; p < pend; p++) {

    if (IS_ESCAPED_CHAR(*p))

      break;

  }

  /* quote */

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

  for (; p < pend; p++) {

    if (IS_ESCAPED_CHAR(*p))

      str_append_c(dest, '\\');

    str_append_data(dest, p, 1);

  }

}

void str_append_unescaped(string_t *dest, const void *src, size_t src_size)

{

  const unsigned char *src_c = src;

  size_t start = 0, i = 0;

  while (i < src_size) {

    for (; i < src_size; i++) {

      if (src_c[i] == '\\')

        break;

    }

    str_append_data(dest, src_c + start, i-start);

    if (i < src_size) {

      if (++i == src_size)

        break;

      str_append_c(dest, src_c[i++]);

    }

    start = i;

  }

}

char *str_unescape(char *str)

{

  /* @UNSAFE */

  char *dest, *start = str;

  while (*str != '\\') {

    if (*str == '\0')

      return start;

    str++;

  }

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

    if (*str == '\\') {

      str++;

      if (*str == '\0')

        break;

    }

    *dest++ = *str;

  }

  *dest = '\0';

  return start;

}

int str_unescape_next(const char **str, const char **unescaped_r)

{

  const char *p;

  char *escaped;

  bool esc_found = FALSE;

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

    if (*p == '"')

      break;

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

      if (p[1] == '\0')

        return -1;

      esc_found = TRUE;

      p++;

    }

  }

  if (*p != '"')

    return -1;

  escaped = p_strdup_until(unsafe_data_stack_pool, *str, p);

  *str = p+1;

  *unescaped_r = !esc_found ? escaped : str_unescape(escaped);

  return 0;

}

void str_append_tabescaped_n(string_t *dest, const unsigned char *src, size_t src_size)

{

  size_t prev_pos = 0;

  char esc[2] = { '\001', '\0' };

  for (size_t i = 0; i < src_size; i++) {

    switch (src[i]) {

    case '\000':

      esc[1] = '0';

      break;

    case '\001':

      esc[1] = '1';

      break;

    case '\t':

      esc[1] = 't';

      break;

    case '\r':

      esc[1] = 'r';

      break;

    case '\n':

      esc[1] = 'n';

      break;

    default:

      continue;

    }

    str_append_data(dest, src + prev_pos, i - prev_pos);

    str_append_data(dest, esc, 2);

    prev_pos = i + 1;

  }

  str_append_data(dest, src + prev_pos, src_size - prev_pos);

}

void str_append_tabescaped(string_t *dest, const char *src)

{

  size_t pos, prev_pos = 0;

  char esc[2] = { '\001', '\0' };

  for (;;) {

    pos = prev_pos + strcspn(src + prev_pos, "\001\t\r\n");

    str_append_data(dest, src + prev_pos, pos - prev_pos);

    prev_pos = pos + 1;

    switch (src[pos]) {

    case '\000':

      /* end of src string reached */

      return;

    case '\001':

      esc[1] = '1';

      break;

    case '\t':

      esc[1] = 't';

      break;

    case '\r':

      esc[1] = 'r';

      break;

    case '\n':

      esc[1] = 'n';

      break;

    default:

      i_unreached();

    }

    str_append_data(dest, esc, 2);

  }

}

const char *str_tabescape(const char *str)

{

  string_t *tmp;

  const char *p;

  if ((p = strpbrk(str, "\001\t\r\n")) != NULL) {

    tmp = t_str_new(128);

    str_append_data(tmp, str, p-str);

    str_append_tabescaped(tmp, p);

    return str_c(tmp);

  }

  return str;

}

void str_append_tabunescaped(string_t *dest, const void *src, size_t src_size)

{

  const unsigned char *src_c = src;

  size_t start = 0, i = 0;

  while (i < src_size) {

    for (; i < src_size; i++) {

      if (src_c[i] == '\001')

        break;

    }

    str_append_data(dest, src_c + start, i-start);

    if (i < src_size) {

      i++;

      if (i < src_size) {

        switch (src_c[i]) {

        case '0':

          str_append_c(dest, '\000');

          break;

        case '1':

          str_append_c(dest, '\001');

          break;

        case 't':

          str_append_c(dest, '\t');

          break;

        case 'r':

          str_append_c(dest, '\r');

          break;

        case 'n':

          str_append_c(dest, '\n');

          break;

        default:

          str_append_c(dest, src_c[i]);

          break;

        }

        i++;

      }

    }

    start = i;

  }

}

static char *str_tabunescape_from(char *str, char *src)

{

  /* @UNSAFE */

  char *dest, *p;

  dest = src;

  for (;;) {

    switch (src[1]) {

    case '\0':

      /* truncated input */

      *dest = '\0';

      return str;

    case '0':

      *dest++ = '\000';

      break;

    case '1':

      *dest++ = '\001';

      break;

    case 't':

      *dest++ = '\t';

      break;

    case 'r':

      *dest++ = '\r';

      break;

    case 'n':

      *dest++ = '\n';

      break;

    default:

      *dest++ = src[1];

      break;

    }

    src += 2;

    p = strchr(src, '\001');

    if (p == NULL) {

      memmove(dest, src, strlen(src)+1);

      break;

    }

    size_t copy_len = p - src;

    memmove(dest, src, copy_len);

    dest += copy_len;

    src = p;

  }

  return str;

}

char *str_tabunescape(char *str)

{

  char *src = strchr(str, '\001');

  if (src == NULL) {

    /* no unescaping needed */

    return str;

  }

  return str_tabunescape_from(str, src);

}

const char *t_str_tabunescape(const char *str)

{

  const char *p;

  p = strchr(str, '\001');

  if (p == NULL)

    return str;

  char *dest = t_strdup_noconst(str);

  return str_tabunescape_from(dest, dest + (p - str));

}

static char **p_strsplit_tabescaped_inplace(pool_t pool, char *data)

{

  /* @UNSAFE */

  char **array;

  unsigned int count, new_alloc_count, alloc_count;

  if (*data == '\0')

    return p_new(pool, char *, 1);

  alloc_count = 32;

  array = pool == unsafe_data_stack_pool ?

    t_malloc_no0(sizeof(char *) * alloc_count) :

    p_malloc(pool, sizeof(char *) * alloc_count);

  array[0] = data; count = 1;

  char *need_unescape = NULL;

  while ((data = strpbrk(data, "\t\001")) != NULL) {

    /* separator or escape char found */

    if (*data == '\001') {

      if (need_unescape == NULL)

        need_unescape = data;

      data++;

      continue;

    }

    if (count+1 >= alloc_count) {

      new_alloc_count = nearest_power(alloc_count+1);

      array = p_realloc(pool, array,

            sizeof(char *) * alloc_count,

            sizeof(char *) *

            new_alloc_count);

      alloc_count = new_alloc_count;

    }

    *data++ = '\0';

    if (need_unescape != NULL) {

      str_tabunescape_from(array[count-1], need_unescape);

      need_unescape = NULL;

    }

    array[count++] = data;

  }

  if (need_unescape != NULL)

    str_tabunescape_from(array[count-1], need_unescape);

  i_assert(count < alloc_count);

  array[count] = NULL;

  return array;

}

const char *const *t_strsplit_tabescaped_inplace(char *data)

{

  char *const *escaped =

    p_strsplit_tabescaped_inplace(unsafe_data_stack_pool, data);

  return (const char *const *)escaped;

}

char **p_strsplit_tabescaped(pool_t pool, const char *str)

{

  return p_strsplit_tabescaped_inplace(pool, p_strdup(pool, str));

}

const char *const *t_strsplit_tabescaped(const char *str)

{

  return t_strsplit_tabescaped_inplace(t_strdup_noconst(str));

}