buffer.c

使用select实现的UNIX/Linux环境下的TCP聊天程序

#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;
}