msgbuf.c

#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "msgbuf.h"

#ifndef MIN
#define MIN(x,y)  (((x) < (y))? (x) : (y))
#endif



struct msgbuf *  msgbuf_new(int bufsize)
{
    struct msgbuf * mbuf;
    mbuf = malloc(sizeof(*mbuf));
    assert(mbuf);
    mbuf->len = bufsize;
    mbuf->buf = malloc(mbuf->len);
    assert(mbuf->len);
    mbuf->start = mbuf->end = 0;

    return mbuf;
}

/**********************************************************************/
int msgbuf_read(struct msgbuf * mbuf, int sock)
{
    int count = read(sock, &mbuf->buf[mbuf->end], mbuf->len - mbuf->end);
    if(count>0)
        mbuf->end+=count;
    if( mbuf->end >= mbuf->len)     // resize buffer if need be
        msgbuf_grow(mbuf);
    return count;
}
/**********************************************************************/
int msgbuf_read_all(struct msgbuf * mbuf, int sock, int len)
{

    int count = 0;
    int tmp;
    while(count < len)
    {
        /** fprintf(stderr, "in msgbuf_read_all... count = %d len = %d tmp = %d\n",
                count, len, tmp); **/
        tmp =msgbuf_read(mbuf,sock);
        if((tmp == 0)  ||
                ((tmp<0) && (errno != EWOULDBLOCK ) && (errno != EINTR) && (errno != EAGAIN)))
            return tmp;
        if(tmp  > 0)
            count+=tmp;
    }
    return count;
}
/**********************************************************************/
int msgbuf_write(struct msgbuf * mbuf, int sock, int len)
{
	int send_len = mbuf->end - mbuf->start;
  int snd = 0, rc;
  fd_set fds;
  struct timeval timeout;
  char *b  = mbuf->buf[mbuf->start];

	if (len > 0)
	{
		if (send_len < len)
			return -1;
		if (send_len > len)
			send_len = len;
  }

  //  while( snd <  send_len) {
  //      timeout.tv_sec = 1;
  //      timeout.tv_usec = 0;
  //      FD_ZERO(&fds);
  //      FD_SET(sock, &fds);
  //      while((rc = select(sizeof(fds)*8, NULL, &fds, NULL, &timeout)) <= 0) {
  //        FD_ZERO(&fds);
  //        FD_SET(sock, &fds);
  //        timeout.tv_sec = 1;
  //        timeout.tv_usec = 0;
  //        if(rc < 0) 
  //          perror_and_exit("select failed", 1);
  //      }
  //
  //      if (FD_ISSET(sock, &fds)) {
  //        snd += write(sock, b + snd, send_len - snd);
  //      }
  //    }

  int count = write(sock, &mbuf->buf[mbuf->start], send_len);
  if(count>0)
    mbuf->start+=count;
  if(mbuf->start >= mbuf->end)
    mbuf->start = mbuf->end = 0;
  return count;
}
/**********************************************************************/
int msgbuf_write_all(struct msgbuf * mbuf, int sock, int len)
{
  int tmp=0,count=0;
  while(mbuf->start < mbuf->end)
  {
    tmp=msgbuf_write(mbuf, sock, len);
    if((tmp < 0) && 
        (errno != EAGAIN) && 
        (errno != EWOULDBLOCK) && 
        (errno != EINTR))

      return tmp;
    if(count > 0)
      count+=tmp;
  }
  return count;
}
/**********************************************************************/
void msgbuf_clear(struct msgbuf * mbuf)
{
  mbuf->start = mbuf->end = 0;
}
/**********************************************************************/
void msgbuf_grow(struct msgbuf * mbuf)
{
  mbuf->len *=2 ;
  mbuf->buf = realloc(mbuf->buf, mbuf->len);
  if(mbuf->buf == NULL) {
    perror("msgbuf_grow failed");
    printf("buffer len: %d\n", mbuf->len);
  }
  assert(mbuf->buf);
}
/**********************************************************************/
void * msgbuf_peek(struct msgbuf *mbuf)
{
  if(mbuf->start >= mbuf->end)
    return NULL;
  return (void *) &mbuf->buf[mbuf->start]; 
}
/**********************************************************************/
int msgbuf_pull(struct msgbuf *mbuf, char * buf, int count)
{
  int min = MIN(count, mbuf->end - mbuf->start);
  if( min <= 0)
    return -1;
  if(buf)     // don't write if NULL
    memcpy(buf, &mbuf->buf[mbuf->start], min);
  mbuf->start+=min;
  if(mbuf->start>= mbuf->end)
    mbuf->start = mbuf->end = 0;
  return min;
}
/**********************************************************************/
void msgbuf_push(struct msgbuf *mbuf, char * buf, int count)
{
  while((mbuf->end + count) > mbuf->len)
    msgbuf_grow(mbuf);
  memcpy(&mbuf->buf[mbuf->end], buf, count);
  mbuf->end += count;
}