/*

 * Copyright (c) 2020 Red Hat, Inc.

 *

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

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 * 02110-1301, USA. 

 *

 * $Id: //eng/uds-releases/jasper/src/uds/buffer.c#3 $

 */

#include "buffer.h"

#include "bufferPrivate.h"

#include "logger.h"

#include "memoryAlloc.h"

#include "numeric.h"

#include "permassert.h"

#include "typeDefs.h"

/**********************************************************************/

int wrapBuffer(byte    *bytes,

               size_t   length,

               size_t   contentLength,

               Buffer **bufferPtr)

{

  int result = ASSERT((contentLength <= length),

                      "content length, %zu, fits in buffer size, %zu",

                      length, contentLength);

  Buffer *buffer;

  result = ALLOCATE(1, Buffer, "buffer", &buffer);

  if (result != UDS_SUCCESS) {

    return result;

  }

  buffer->data    = bytes;

  buffer->start   = 0;

  buffer->end     = contentLength;

  buffer->length  = length;

  buffer->wrapped = true;

  *bufferPtr      = buffer;

  return UDS_SUCCESS;

}

/***********************************************************************/

int makeBuffer(size_t size, Buffer **newBuffer)

{

  byte *data;

  int result = ALLOCATE(size, byte, "buffer data", &data);

  if (result != UDS_SUCCESS) {

    return result;

  }

  Buffer *buffer;

  result = wrapBuffer(data, size, 0, &buffer);

  if (result != UDS_SUCCESS) {

    FREE(data);

    return result;

  }

  buffer->wrapped = false;

  *newBuffer = buffer;

  return UDS_SUCCESS;

}

/***********************************************************************/

void freeBuffer(Buffer **pBuffer)

{

  Buffer *buffer = *pBuffer;

  *pBuffer = NULL;

  if (buffer == NULL) {

    return;

  }

  if (!buffer->wrapped) {

    FREE(buffer->data);

  }

  FREE(buffer);

}

/**********************************************************************/

size_t bufferLength(Buffer *buffer)

{

  return buffer->length;

}

/**********************************************************************/

size_t contentLength(Buffer *buffer)

{

  return buffer->end - buffer->start;

}

/**********************************************************************/

size_t uncompactedAmount(Buffer *buffer)

{

  return buffer->start;

}

/**********************************************************************/

size_t availableSpace(Buffer *buffer)

{

  return buffer->length - buffer->end;

}

/**********************************************************************/

size_t bufferUsed(Buffer *buffer)

{

  return buffer->end;

}

/***********************************************************************/

int growBuffer(Buffer *buffer, size_t length)

{

  if (buffer == NULL) {

    return logWarningWithStringError(UDS_INVALID_ARGUMENT,

                                     "cannot resize NULL buffer");

  }

  if (buffer->wrapped) {

    return logWarningWithStringError(UDS_INVALID_ARGUMENT,

                                     "cannot resize wrapped buffer");

  }

  if (buffer->end > length) {

    return logWarningWithStringError(UDS_INVALID_ARGUMENT,

                                     "cannot shrink buffer");

  }

  byte *data;

  int result = reallocateMemory(buffer->data, buffer->length, length,

                                "buffer data", &data);

  if (result != UDS_SUCCESS) {

    return result;

  }

  buffer->data   = data;

  buffer->length = length;

  return UDS_SUCCESS;

}

/***********************************************************************/

bool ensureAvailableSpace(Buffer *buffer, size_t bytes)

{

  if (availableSpace(buffer) >= bytes) {

    return true;

  }

  compactBuffer(buffer);

  return (availableSpace(buffer) >= bytes);

}

/***********************************************************************/

void clearBuffer(Buffer *buffer)

{

  buffer->start = 0;

  buffer->end = buffer->length;

}

/***********************************************************************/

void compactBuffer(Buffer *buffer)

{

  if ((buffer->start == 0) || (buffer->end == 0)) {

    return;

  }

  size_t bytesToMove = buffer->end - buffer->start;

  memmove(buffer->data, buffer->data + buffer->start, bytesToMove);

  buffer->start = 0;

  buffer->end = bytesToMove;

}

/**********************************************************************/

int resetBufferEnd(Buffer *buffer, size_t end)

{

  if (end > buffer->length) {

    return UDS_BUFFER_ERROR;

  }

  buffer->end = end;

  if (buffer->start > buffer->end) {

    buffer->start = buffer->end;

  }

  return UDS_SUCCESS;

}

/**********************************************************************/

int skipForward(Buffer *buffer, size_t bytesToSkip)

{

  if (contentLength(buffer) < bytesToSkip) {

    return UDS_BUFFER_ERROR;

  }

  buffer->start += bytesToSkip;

  return UDS_SUCCESS;

}

/**********************************************************************/

int rewindBuffer(Buffer *buffer, size_t bytesToRewind)

{

  if (buffer->start < bytesToRewind) {

    return UDS_BUFFER_ERROR;

  }

  buffer->start -= bytesToRewind;

  return UDS_SUCCESS;

}

/**********************************************************************/

bool hasSameBytes(Buffer *buffer, const byte *data, size_t length)

{

  return ((contentLength(buffer) >= length)

          && (memcmp(buffer->data + buffer->start, data, length) == 0));

}

/**********************************************************************/

bool equalBuffers(Buffer *buffer1, Buffer *buffer2)

{

  return hasSameBytes(buffer1, buffer2->data + buffer2->start,

                      contentLength(buffer2));

}

/**********************************************************************/

int getByte(Buffer *buffer, byte *bytePtr)

{

  if (contentLength(buffer) < sizeof(byte)) {

    return UDS_BUFFER_ERROR;

  }

  *bytePtr = buffer->data[buffer->start++];

  return UDS_SUCCESS;

}

/**********************************************************************/

int peekByte(Buffer *buffer, size_t offset, byte *bytePtr)

{

  if (contentLength(buffer) < (offset + sizeof(byte))) {

    return UDS_BUFFER_ERROR;

  }

  *bytePtr = buffer->data[buffer->start + offset];

  return UDS_SUCCESS;

}

/**********************************************************************/

int putByte(Buffer *buffer, byte b)

{

  if (!ensureAvailableSpace(buffer, sizeof(byte))) {

    return UDS_BUFFER_ERROR;

  }

  buffer->data[buffer->end++] = b;

  return UDS_SUCCESS;

}

/**********************************************************************/

int getBytesFromBuffer(Buffer *buffer, size_t length, void *destination)

{

  if (contentLength(buffer) < length) {

    return UDS_BUFFER_ERROR;

  }

  memcpy(destination, buffer->data + buffer->start, length);

  buffer->start += length;

  return UDS_SUCCESS;

}

/**********************************************************************/

byte *getBufferContents(Buffer *buffer)

{

  return buffer->data + buffer->start;

}

/**********************************************************************/

int copyBytes(Buffer *buffer, size_t length, byte **destinationPtr)

{

  byte *destination;

  int   result = ALLOCATE(length, byte, "copyBytes() buffer",

                          &destination);

  if (result != UDS_SUCCESS) {

    return result;

  }

  result = getBytesFromBuffer(buffer, length, destination);

  if (result != UDS_SUCCESS) {

    FREE(destination);

  } else {

    *destinationPtr = destination;

  }

  return result;

}

/**********************************************************************/

int putBytes(Buffer *buffer, size_t length, const void *source)

{

  if (!ensureAvailableSpace(buffer, length)) {

    return UDS_BUFFER_ERROR;

  }

  memcpy(buffer->data + buffer->end, source, length);

  buffer->end += length;

  return UDS_SUCCESS;

}

/**********************************************************************/

int putBuffer(Buffer *target, Buffer *source, size_t length)

{

  if (contentLength(source) < length) {

    return UDS_BUFFER_ERROR;

  }

  int result = putBytes(target, length, getBufferContents(source));

  if (result != UDS_SUCCESS) {

    return result;

  }

  source->start += length;

  return UDS_SUCCESS;

}

/**********************************************************************/

int zeroBytes(Buffer *buffer, size_t length)

{

  if (!ensureAvailableSpace(buffer, length)) {

    return UDS_BUFFER_ERROR;

  }

  memset(buffer->data + buffer->end, 0, length);

  buffer->end += length;

  return UDS_SUCCESS;

}

/**********************************************************************/

int getBoolean(Buffer *buffer, bool *b)

{

  byte by;

  int result = getByte(buffer, &by;;

  if (result == UDS_SUCCESS) {

    *b = (by == 1);

  }

  return result;

}

/**********************************************************************/

int putBoolean(Buffer *buffer, bool b)

{

  return putByte(buffer, (byte) (b ? 1 : 0));

}

/**********************************************************************/

int getUInt16BEFromBuffer(Buffer *buffer, uint16_t *ui)

{

  if (contentLength(buffer) < sizeof(uint16_t)) {

    return UDS_BUFFER_ERROR;

  }

  decodeUInt16BE(buffer->data, &buffer->start, ui);

  return UDS_SUCCESS;

}

/**********************************************************************/

int putUInt16BEIntoBuffer(Buffer *buffer, uint16_t ui)

{

  if (!ensureAvailableSpace(buffer, sizeof(uint16_t))) {

    return UDS_BUFFER_ERROR;

  }

  encodeUInt16BE(buffer->data, &buffer->end, ui);

  return UDS_SUCCESS;

}

/**********************************************************************/

int getUInt32BEFromBuffer(Buffer *buffer, uint32_t *ui)

{

  if (contentLength(buffer) < sizeof(uint32_t)) {

    return UDS_BUFFER_ERROR;

  }

  decodeUInt32BE(buffer->data, &buffer->start, ui);

  return UDS_SUCCESS;

}

/**********************************************************************/

int putUInt32BEIntoBuffer(Buffer *buffer, uint32_t ui)

{

  if (!ensureAvailableSpace(buffer, sizeof(uint32_t))) {

    return UDS_BUFFER_ERROR;

  }

  encodeUInt32BE(buffer->data, &buffer->end, ui);

  return UDS_SUCCESS;

}

/**********************************************************************/

int getUInt32BEsFromBuffer(Buffer *buffer, size_t count, uint32_t *ui)

{

  if (contentLength(buffer) < (sizeof(uint32_t) * count)) {

    return UDS_BUFFER_ERROR;

  }

  unsigned int i;

  for (i = 0; i < count; i++) {

    decodeUInt32BE(buffer->data, &buffer->start, ui + i);

  }

  return UDS_SUCCESS;

}

/**********************************************************************/

int putUInt32BEsIntoBuffer(Buffer *buffer, size_t count, const uint32_t *ui)

{

  if (!ensureAvailableSpace(buffer, sizeof(uint32_t) * count)) {

    return UDS_BUFFER_ERROR;

  }

  unsigned int i;

  for (i = 0; i < count; i++) {

    encodeUInt32BE(buffer->data, &buffer->end, ui[i]);

  }

  return UDS_SUCCESS;

}

/**********************************************************************/

int getUInt64BEsFromBuffer(Buffer *buffer, size_t count, uint64_t *ui)

{

  if (contentLength(buffer) < (sizeof(uint64_t) * count)) {

    return UDS_BUFFER_ERROR;

  }

  unsigned int i;

  for (i = 0; i < count; i++) {

    decodeUInt64BE(buffer->data, &buffer->start, ui + i);

  }

  return UDS_SUCCESS;

}

/**********************************************************************/

int putUInt64BEsIntoBuffer(Buffer *buffer, size_t count, const uint64_t *ui)

{

  if (!ensureAvailableSpace(buffer, sizeof(uint64_t) * count)) {

    return UDS_BUFFER_ERROR;

  }

  unsigned int i;

  for (i = 0; i < count; i++) {

    encodeUInt64BE(buffer->data, &buffer->end, ui[i]);

  }

  return UDS_SUCCESS;

}

/**********************************************************************/

int getUInt16LEFromBuffer(Buffer *buffer, uint16_t *ui)

{

  if (contentLength(buffer) < sizeof(uint16_t)) {

    return UDS_BUFFER_ERROR;

  }

  decodeUInt16LE(buffer->data, &buffer->start, ui);

  return UDS_SUCCESS;

}

/**********************************************************************/

int putUInt16LEIntoBuffer(Buffer *buffer, uint16_t ui)

{

  if (!ensureAvailableSpace(buffer, sizeof(uint16_t))) {

    return UDS_BUFFER_ERROR;

  }

  encodeUInt16LE(buffer->data, &buffer->end, ui);

  return UDS_SUCCESS;

}

/**********************************************************************/

int getUInt16LEsFromBuffer(Buffer *buffer, size_t count, uint16_t *ui)

{

  if (contentLength(buffer) < (sizeof(uint16_t) * count)) {

    return UDS_BUFFER_ERROR;

  }

  unsigned int i;

  for (i = 0; i < count; i++) {

    decodeUInt16LE(buffer->data, &buffer->start, ui + i);

  }

  return UDS_SUCCESS;

}

/**********************************************************************/

int putUInt16LEsIntoBuffer(Buffer *buffer, size_t count, const uint16_t *ui)

{

  if (!ensureAvailableSpace(buffer, sizeof(uint16_t) * count)) {

    return UDS_BUFFER_ERROR;

  }

  unsigned int i;

  for (i = 0; i < count; i++) {

    encodeUInt16LE(buffer->data, &buffer->end, ui[i]);

  }

  return UDS_SUCCESS;

}

/**********************************************************************/

int getInt32LEFromBuffer(Buffer *buffer, int32_t *i)

{

  if (contentLength(buffer) < sizeof(int32_t)) {

    return UDS_BUFFER_ERROR;

  }

  decodeInt32LE(buffer->data, &buffer->start, i);

  return UDS_SUCCESS;

}

/**********************************************************************/

int getUInt32LEFromBuffer(Buffer *buffer, uint32_t *ui)

{

  if (contentLength(buffer) < sizeof(uint32_t)) {

    return UDS_BUFFER_ERROR;

  }

  decodeUInt32LE(buffer->data, &buffer->start, ui);

  return UDS_SUCCESS;

}

/**********************************************************************/

int putUInt32LEIntoBuffer(Buffer *buffer, uint32_t ui)

{

  if (!ensureAvailableSpace(buffer, sizeof(uint32_t))) {

    return UDS_BUFFER_ERROR;

  }

  encodeUInt32LE(buffer->data, &buffer->end, ui);

  return UDS_SUCCESS;

}

/**********************************************************************/

int putInt64LEIntoBuffer(Buffer *buffer, int64_t i)

{

  if (!ensureAvailableSpace(buffer, sizeof(int64_t))) {

    return UDS_BUFFER_ERROR;

  }

  encodeInt64LE(buffer->data, &buffer->end, i);

  return UDS_SUCCESS;

}

/**********************************************************************/

int getUInt64LEFromBuffer(Buffer *buffer, uint64_t *ui)

{

  if (contentLength(buffer) < sizeof(uint64_t)) {

    return UDS_BUFFER_ERROR;

  }

  decodeUInt64LE(buffer->data, &buffer->start, ui);

  return UDS_SUCCESS;

}

/**********************************************************************/

int putUInt64LEIntoBuffer(Buffer *buffer, uint64_t ui)

{

  if (!ensureAvailableSpace(buffer, sizeof(uint64_t))) {

    return UDS_BUFFER_ERROR;

  }

  encodeUInt64LE(buffer->data, &buffer->end, ui);

  return UDS_SUCCESS;

}

/**********************************************************************/

int getUInt64LEsFromBuffer(Buffer *buffer, size_t count, uint64_t *ui)

{

  if (contentLength(buffer) < (sizeof(uint64_t) * count)) {

    return UDS_BUFFER_ERROR;

  }

  unsigned int i;

  for (i = 0; i < count; i++) {

    decodeUInt64LE(buffer->data, &buffer->start, ui + i);

  }

  return UDS_SUCCESS;

}

/**********************************************************************/

int putUInt64LEsIntoBuffer(Buffer *buffer, size_t count, const uint64_t *ui)

{

  if (!ensureAvailableSpace(buffer, sizeof(uint64_t) * count)) {

    return UDS_BUFFER_ERROR;

  }

  unsigned int i;

  for (i = 0; i < count; i++) {

    encodeUInt64LE(buffer->data, &buffer->end, ui[i]);

  }

  return UDS_SUCCESS;

}