/*

 * $Id: printbuf.c,v 1.5 2006/01/26 02:16:28 mclark Exp $

 *

 * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd.

 * Michael Clark <michael@metaparadigm.com>

 *

 * This library is free software; you can redistribute it and/or modify

 * it under the terms of the MIT license. See COPYING for details.

 *

 *

 * Copyright (c) 2008-2009 Yahoo! Inc.  All rights reserved.

 * The copyrights to the contents of this file are licensed under the MIT License

 * (https://www.opensource.org/licenses/mit-license.php)

 */

#include "config.h"

#include <errno.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef HAVE_STDARG_H

#include <stdarg.h>

#else /* !HAVE_STDARG_H */

#error Not enough var arg support!

#endif /* HAVE_STDARG_H */

#include "debug.h"

#include "json_inttypes.h"

#include "printbuf.h"

#include "snprintf_compat.h"

#include "vasprintf_compat.h"

static int printbuf_extend(struct printbuf *p, int min_size);

struct printbuf *printbuf_new(void)

{

  struct printbuf *p;

  p = (struct printbuf *)calloc(1, sizeof(struct printbuf));

  if (!p)

    return NULL;

  p->size = 32;

  p->bpos = 0;

  if (!(p->buf = (char *)malloc(p->size)))

  {

    free(p);

    return NULL;

  }

  p->buf[0] = '\0';

  return p;

}

/**

 * Extend the buffer p so it has a size of at least min_size.

 *

 * If the current size is large enough, nothing is changed.

 *

 * If extension failed, errno is set to indicate the error.

 *

 * Note: this does not check the available space!  The caller

 *  is responsible for performing those calculations.

 */

static int printbuf_extend(struct printbuf *p, int min_size)

{

  char *t;

  int new_size;

  if (p->size >= min_size)

    return 0;

  /* Prevent signed integer overflows with large buffers. */

  if (min_size > INT_MAX - 8)

  {

    errno = EFBIG;

    return -1;

  }

  if (p->size > INT_MAX / 2)

    new_size = min_size + 8;

  else {

    new_size = p->size * 2;

    if (new_size < min_size + 8)

      new_size = min_size + 8;

  }

#ifdef PRINTBUF_DEBUG

  MC_DEBUG("printbuf_extend: realloc "

           "bpos=%d min_size=%d old_size=%d new_size=%d\n",

           p->bpos, min_size, p->size, new_size);

#endif /* PRINTBUF_DEBUG */

  if (!(t = (char *)realloc(p->buf, new_size)))

    return -1;

  p->size = new_size;

  p->buf = t;

  return 0;

}

int printbuf_memappend(struct printbuf *p, const char *buf, int size)

{

  /* Prevent signed integer overflows with large buffers. */

  if (size < 0 || size > INT_MAX - p->bpos - 1)

  {

    errno = EFBIG;

    return -1;

  }

  if (p->size <= p->bpos + size + 1)

  {

    int buf_offset = -1;

    const uintptr_t buf_addr = (uintptr_t)(const void *)buf;

    const uintptr_t p_buf_addr = (uintptr_t)(const void *)p->buf;

    /* realloc() invalidates source pointers into the old buffer. */

    if (buf_addr >= p_buf_addr && buf_addr - p_buf_addr < (uintptr_t)p->size)

      buf_offset = (int)(buf_addr - p_buf_addr);

    if (printbuf_extend(p, p->bpos + size + 1) < 0)

      return -1;

    if (buf_offset >= 0)

      buf = p->buf + buf_offset;

  }

  memmove(p->buf + p->bpos, buf, size);

  p->bpos += size;

  p->buf[p->bpos] = '\0';

  return size;

}

int printbuf_memset(struct printbuf *pb, int offset, int charvalue, int len)

{

  int size_needed;

  if (offset == -1)

    offset = pb->bpos;

  /* Prevent signed integer overflows with large buffers. */

  if (len < 0 || offset < -1 || len > INT_MAX - offset)

  {

    errno = EFBIG;

    return -1;

  }

  size_needed = offset + len;

  /* + 1 keeps the printbuf invariant that buf[bpos] is '\0' after every

   * operation; without it, reading pb->buf as a C string right after an

   * indent() consumes uninitialized bytes. */

  if (pb->size < size_needed + 1)

  {

    if (printbuf_extend(pb, size_needed + 1) < 0)

      return -1;

  }

  if (pb->bpos < offset)

    memset(pb->buf + pb->bpos, '\0', offset - pb->bpos);

  memset(pb->buf + offset, charvalue, len);

  if (pb->bpos < size_needed)

    pb->bpos = size_needed;

  pb->buf[pb->bpos] = '\0';

  return 0;

}

int sprintbuf(struct printbuf *p, const char *msg, ...)

{

  va_list ap;

  char *t;

  int size;

  char buf[128];

  /* use stack buffer first */

  va_start(ap, msg);

  size = vsnprintf(buf, 128, msg, ap);

  va_end(ap);

  /* if string is greater than stack buffer, then use dynamic string

   * with vasprintf.  Note: some implementations of vsnprintf return -1

   * if output is truncated whereas some return the number of bytes that

   * would have been written - this code handles both cases.

   */

  if (size < 0 || size > 127)

  {

    va_start(ap, msg);

    if ((size = vasprintf(&t, msg, ap)) < 0)

    {

      va_end(ap);

      return -1;

    }

    va_end(ap);

    size = printbuf_memappend(p, t, size);

    free(t);

  }

  else

  {

    size = printbuf_memappend(p, buf, size);

  }

  return size;

}

void printbuf_reset(struct printbuf *p)

{

  p->buf[0] = '\0';

  p->bpos = 0;

}

void printbuf_free(struct printbuf *p)

{

  if (p)

  {

    free(p->buf);

    free(p);

  }

}