#include <stdio.h>#include <stdlib.h>#include <string.h>#include <errno.h>#include "buffer.h"buffer_t *buffer_create(unsigned long size, unsigned long maxsize){  buffer_t *buf;  if (size == 0 && maxsize == 0)  {    return NULL;  }  if (maxsize < size)  {    maxsize = size;  }  if ((buf = (buffer_t *) malloc(sizeof(buffer_t))) == NULL)  {    fprintf(stderr, "allocate memory failed: %s\n", strerror(errno));    return NULL;  }  buf->size = size;  buf->maxsize = maxsize;  buf->length = 0;  if ((buf->p = (char *) malloc(buf->size)) == NULL)  {    fprintf(stderr, "allocate memory failed: %s\n", strerror(errno));    free(buf);    return NULL;  }  return buf;}void buffer_destroy(buffer_t * buf){  if (buf)  {    if (buf->p)    {      free(buf->p);      buf->p = NULL;    }    free(buf);    buf = NULL;  }}int buffer_append_data(buffer_t * buf, char *data, unsigned long length){  if (!buf || !buf->p)    return -1;  if (buf->size - buf->length > length)  {    //void *memcpy(void *dest, const void *src, size_t n);    memcpy(buf->p + buf->length, data, length);    buf->length += length;    return 0;  }  else  {    int n;    if ((n = buffer_resize(buf, buf->length + length)) >= buf->length + length)    {      memcpy(buf->p + buf->length, data, length);      buf->length += length;      return 0;    }    else    {      if (n == -1)      {	fprintf(stderr, "Object %p is bad.\n", buf);      }      else if (n == -2)      {	fprintf(stderr, "Expected newsize of object %p is short than original size.\n", buf);      }      else      {	fprintf(stderr, "Object %p is left untouched.\n", buf);      }      return -1;    }  }  return 0;}char *buffer_fetch_data(buffer_t * buf, unsigned long length, unsigned long *rlength){  char *p;  if ((p = malloc(length)) == NULL)  {    return NULL;  }  //*rlength = buf->length > length ? length : buf->length;  if (buf->length > length)  {    *rlength = length;  }  else  {    *rlength = buf->length;  }  // void *memcpy(void *dest, const void *src, size_t n);  memcpy(p, buf->p, *rlength);  if (buf->length - *rlength > 0)  {    // void *memmove(void *dest, const void *src, size_t n);    memmove(buf->p, buf->p + *rlength, buf->length - *rlength);    buf->length = buf->length - *rlength;  }  else  {    buf->length = 0;  }  return p;}int buffer_remove_data(buffer_t * buf, unsigned long length){  if (length < buf->length)  {    memmove(buf->p, buf->p + length, buf->length - length);    buf->length = buf->length - length;  }  else  {    buf->length = 0;  }  return 0;}int buffer_resize(buffer_t * buf, int newsize){  unsigned long size;  char *p;  if (!buf || !buf->p)  {    return -1;  }  if (buf->size > newsize)  {    return -2;  }  size = newsize;  if (buf->maxsize < size)  {    size = buf->maxsize;  }  // void *realloc(void *ptr, size_t size);  if ((p = realloc(buf->p, size)) == NULL)  {    /*     * realloc() returns a pointer to the newly allocated memory, which is suitably aligned  for any kind of     * variable and may be different from ptr, or NULL if the request fails. If size was equal to 0, either     * NULL or a pointer suitable to be passed to free() is returned.      * If realloc() fails the original block is left untouched - it is not freed or moved.     */    return buf->size;  }  else  {    buf->p = p;    buf->size = size;    return size;  }  return 0;}unsigned long buffer_get_length(buffer_t * buf){  return buf->length;}unsigned long buffer_get_size(buffer_t * buf){  return buf->size;}unsigned long buffer_get_maxsize(buffer_t * buf){  return buf->maxsize;}