buffer.c

Go to the documentation of this file.

 
#include "config.h"
#include <errno.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "buffer.h"
#include "exit.h"
#include "logging2.h"
#include "memory.h"
#include "message.h"
#include "string2.h"
 
static const int BufferStepSize = 128;
 
struct Buffer *buf_init(struct Buffer *buf)
{
  if (!buf)
    return NULL;
  memset(buf, 0, sizeof(struct Buffer));
  return buf;
}
 
void buf_reset(struct Buffer *buf)
{
  if (!buf || !buf->data || (buf->dsize == 0))
    return;
  memset(buf->data, 0, buf->dsize);
  buf_seek(buf, 0);
}
 
size_t buf_addstr_n(struct Buffer *buf, const char *s, size_t len)
{
  if (!buf || !s)
    return 0;
 
  if (len > (SIZE_MAX - BufferStepSize))
  {
    // LCOV_EXCL_START
    mutt_error("%s", strerror(ENOMEM));
    mutt_exit(1);
    // LCOV_EXCL_STOP
  }
 
  if (!buf->data || !buf->dptr || ((buf->dptr + len + 1) > (buf->data + buf->dsize)))
    buf_alloc(buf, buf->dsize + MAX(BufferStepSize, len + 1));
 
  memcpy(buf->dptr, s, len);
  buf->dptr += len;
  *(buf->dptr) = '\0';
  return len;
}
 
static int buf_vaprintf(struct Buffer *buf, const char *fmt, va_list ap)
{
  if (!buf || !fmt)
    return 0; /* LCOV_EXCL_LINE */
 
  buf_alloc(buf, 128);
 
  int doff = buf->dptr - buf->data;
  int blen = buf->dsize - doff;
 
  va_list ap_retry;
  va_copy(ap_retry, ap);
 
  int len = vsnprintf(buf->dptr, blen, fmt, ap);
  if (len >= blen)
  {
    buf_alloc(buf, buf->dsize + len - blen + 1);
    len = vsnprintf(buf->dptr, len + 1, fmt, ap_retry);
  }
  if (len > 0)
    buf->dptr += len;
 
  va_end(ap_retry);
 
  return len;
}
 
int buf_printf(struct Buffer *buf, const char *fmt, ...)
{
  if (!buf || !fmt)
    return -1;
 
  va_list ap;
 
  va_start(ap, fmt);
  buf_reset(buf);
  int len = buf_vaprintf(buf, fmt, ap);
  va_end(ap);
 
  return len;
}
 
void buf_fix_dptr(struct Buffer *buf)
{
  if (!buf)
    return;
 
  buf_seek(buf, 0);
 
  if (buf->data && (buf->dsize > 0))
  {
    buf->data[buf->dsize - 1] = '\0';
    buf->dptr = strchr(buf->data, '\0');
  }
}
 
int buf_add_printf(struct Buffer *buf, const char *fmt, ...)
{
  if (!buf || !fmt)
    return -1;
 
  va_list ap;
 
  va_start(ap, fmt);
  int len = buf_vaprintf(buf, fmt, ap);
  va_end(ap);
 
  return len;
}
 
size_t buf_addstr(struct Buffer *buf, const char *s)
{
  if (!buf || !s)
    return 0;
  return buf_addstr_n(buf, s, mutt_str_len(s));
}
 
size_t buf_addch(struct Buffer *buf, char c)
{
  if (!buf)
    return 0;
  return buf_addstr_n(buf, &c, 1);
}
 
size_t buf_insert(struct Buffer *buf, size_t offset, const char *s)
{
  if (!buf || !s || (*s == '\0'))
  {
    return -1;
  }
 
  const size_t slen = mutt_str_len(s);
  const size_t curlen = buf_len(buf);
  buf_alloc(buf, curlen + slen + 1);
 
  if (offset > curlen)
  {
    for (size_t i = curlen; i < offset; ++i)
    {
      buf_addch(buf, ' ');
    }
    buf_addstr(buf, s);
  }
  else
  {
    memmove(buf->data + offset + slen, buf->data + offset, curlen - offset);
    memcpy(buf->data + offset, s, slen);
    buf->data[curlen + slen] = '\0';
    buf->dptr = buf->data + curlen + slen;
  }
 
  return buf_len(buf) - curlen;
}
 
bool buf_is_empty(const struct Buffer *buf)
{
  if (!buf || !buf->data)
    return true;
 
  return (buf->data[0] == '\0');
}
 
struct Buffer *buf_new(const char *str)
{
  struct Buffer *buf = MUTT_MEM_CALLOC(1, struct Buffer);
 
  if (str)
    buf_addstr(buf, str);
  else
    buf_alloc(buf, 1);
  return buf;
}
 
void buf_free(struct Buffer **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct Buffer *buf = *ptr;
  buf_dealloc(buf);
 
  FREE(ptr);
}
 
void buf_alloc(struct Buffer *buf, size_t new_size)
{
  if (!buf)
    return;
 
  if (buf->data && (new_size <= buf->dsize))
  {
    // Extra sanity-checking
    if (!buf->dptr || (buf->dptr < buf->data) || (buf->dptr > (buf->data + buf->dsize)))
      buf->dptr = buf->data; // LCOV_EXCL_LINE
    return;
  }
 
  if (new_size > (SIZE_MAX - BufferStepSize))
  {
    // LCOV_EXCL_START
    mutt_error(_("Out of memory"));
    mutt_exit(1);
    // LCOV_EXCL_STOP
  }
 
  const bool was_empty = (buf->dptr == NULL);
  const size_t offset = (buf->dptr && buf->data) ? (buf->dptr - buf->data) : 0;
 
  buf->dsize = ROUND_UP(new_size + 1, BufferStepSize);
 
  MUTT_MEM_REALLOC(&buf->data, buf->dsize, char);
  buf->dptr = buf->data + offset;
 
  // Ensures that initially NULL buf->data is properly terminated
  if (was_empty)
  {
    *buf->dptr = '\0';
  }
}
 
void buf_dealloc(struct Buffer *buf)
{
  if (!buf || !buf->data)
    return;
 
  buf->dptr = NULL;
  buf->dsize = 0;
  FREE(&buf->data);
}
 
size_t buf_strcpy(struct Buffer *buf, const char *s)
{
  if (!buf)
    return 0;
 
  buf_reset(buf);
  if (!s)
    return 0;
 
  return buf_addstr(buf, s);
}
 
size_t buf_strcpy_n(struct Buffer *buf, const char *s, size_t len)
{
  if (!buf)
    return 0;
 
  buf_reset(buf);
  if (!s)
    return 0;
 
  return buf_addstr_n(buf, s, len);
}
 
void buf_dequote_comment(struct Buffer *buf)
{
  if (!buf || !buf->data || (buf->dsize == 0))
    return;
 
  buf_seek(buf, 0);
 
  char *s = buf->data;
  for (; *buf->dptr; buf->dptr++)
  {
    if (*buf->dptr == '\\')
    {
      if (!*++buf->dptr)
        break; /* error? */
      *s++ = *buf->dptr;
    }
    else if (*buf->dptr != '\"')
    {
      if (s != buf->dptr)
        *s = *buf->dptr;
      s++;
    }
  }
  *s = '\0';
 
  buf_fix_dptr(buf);
}
 
size_t buf_substrcpy(struct Buffer *buf, const char *beg, const char *end)
{
  if (!buf)
    return 0;
 
  buf_reset(buf);
  if (!beg || !end)
    return 0;
 
  if (end <= beg)
    return 0;
 
  return buf_strcpy_n(buf, beg, end - beg);
}
 
size_t buf_len(const struct Buffer *buf)
{
  if (!buf || !buf->data || !buf->dptr)
    return 0;
 
  return buf->dptr - buf->data;
}
 
size_t buf_concat_path(struct Buffer *buf, const char *dir, const char *fname)
{
  if (!buf)
    return 0;
 
  if (!dir)
    dir = "";
  if (!fname)
    fname = "";
 
  const bool d_set = (dir[0] != '\0');
  const bool f_set = (fname[0] != '\0');
  if (!d_set && !f_set)
    return 0;
 
  const int d_len = strlen(dir);
  const bool slash = d_set && (dir[d_len - 1] == '/');
 
  const char *fmt = "%s/%s";
  if (!f_set || !d_set || slash)
    fmt = "%s%s";
 
  return buf_printf(buf, fmt, dir, fname);
}
 
size_t buf_concatn_path(struct Buffer *buf, const char *dir, size_t dirlen,
                        const char *fname, size_t fnamelen)
{
  if (!buf)
    return 0;
 
  buf_reset(buf);
 
  size_t len = 0;
  if (dirlen != 0)
    len += buf_addstr_n(buf, dir, dirlen);
  if ((dirlen != 0) && (fnamelen != 0))
    len += buf_addch(buf, '/');
  if (fnamelen != 0)
    len += buf_addstr_n(buf, fname, fnamelen);
  return len;
}
 
char *buf_strdup(const struct Buffer *buf)
{
  if (!buf)
    return NULL;
 
  return mutt_str_dup(buf->data);
}
 
struct Buffer *buf_dup(const struct Buffer *buf)
{
  if (!buf)
    return NULL;
 
  return buf_new(buf_string(buf));
}
 
size_t buf_copy(struct Buffer *dst, const struct Buffer *src)
{
  if (!dst)
    return 0;
 
  buf_reset(dst);
  if (!src || !src->data)
    return 0;
 
  return buf_addstr_n(dst, src->data, buf_len(src));
}
 
void buf_seek(struct Buffer *buf, size_t offset)
{
  if (!buf)
    return;
 
  if ((offset < buf_len(buf)))
  {
    buf->dptr = buf->data ? buf->data + offset : NULL;
  }
}
 
const char *buf_find_string(const struct Buffer *buf, const char *s)
{
  if (!buf || !s)
    return NULL;
 
  return strstr(buf->data, s);
}
 
const char *buf_find_char(const struct Buffer *buf, const char c)
{
  if (!buf)
    return NULL;
 
  return strchr(buf->data, c);
}
 
char buf_at(const struct Buffer *buf, size_t offset)
{
  if (!buf || (offset > buf_len(buf)))
    return '\0';
 
  return buf->data[offset];
}
 
bool buf_str_equal(const struct Buffer *a, const struct Buffer *b)
{
  return mutt_str_equal(buf_string(a), buf_string(b));
}
 
bool buf_istr_equal(const struct Buffer *a, const struct Buffer *b)
{
  return mutt_istr_equal(buf_string(a), buf_string(b));
}
 
size_t buf_startswith(const struct Buffer *buf, const char *prefix)
{
  if (!buf || !prefix)
    return 0;
 
  return mutt_str_startswith(buf_string(buf), prefix);
}
 
int buf_coll(const struct Buffer *a, const struct Buffer *b)
{
  return mutt_str_coll(buf_string(a), buf_string(b));
}
 
void buf_lower(struct Buffer *buf)
{
  if (!buf)
    return;
 
  mutt_str_lower(buf->data);
}
 
void buf_join_str(struct Buffer *buf, const char *str, char sep)
{
  if (!buf || !str)
    return;
 
  if (!buf_is_empty(buf) && mutt_str_len(str))
    buf_addch(buf, sep);
 
  buf_addstr(buf, str);
}
 
/*
 * buf_inline_replace - Replace part of a string
 * @param buf   Buffer to modify
 * @param pos   Starting position of string to overwrite
 * @param len   Length of string to overwrite
 * @param str   Replacement string
 *
 * String (`11XXXOOOOOO`, 2, 3, `YYYY`) becomes `11YYYY000000`
 */
void buf_inline_replace(struct Buffer *buf, size_t pos, size_t len, const char *str)
{
  if (!buf || !str)
    return;
 
  size_t olen = buf->dsize;
  size_t rlen = mutt_str_len(str);
 
  size_t new_size = buf->dsize - len + rlen + 1;
  if (new_size > buf->dsize)
    buf_alloc(buf, new_size);
 
  memmove(buf->data + pos + rlen, buf->data + pos + len, olen - pos - len);
  memmove(buf->data + pos, str, rlen);
 
  buf_fix_dptr(buf);
}
 
const char *buf_rfind(const struct Buffer *buf, const char *str)
{
  if (buf_is_empty(buf) || !str)
    return NULL;
 
  int len = strlen(str);
  const char *end = buf->data + buf->dsize - len;
 
  for (const char *p = end; p >= buf->data; --p)
  {
    for (size_t i = 0; i < len; i++)
    {
      if (p[i] != str[i])
        goto next;
    }
    return p;
 
  next:;
  }
  return NULL;
}