Logo Search packages:      
Sourcecode: scamper version File versions  Download package

scamper_linepoll.c

/*
 * scamper_linepoll
 *
 * $Id: scamper_linepoll.c,v 1.9.2.1 2007/12/03 07:23:38 mjl Exp $
 *
 * this code takes a string chunk and splits it up into lines, calling
 * the callback for each line.  It buffers any partial lines in the
 * process.
 *
 * Copyright (C) 2004-2007 The University of Waikato
 *
 * 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, version 2.
 *
 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 */

#include <sys/types.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>

#if defined(__APPLE__)
#include <stdint.h>
#endif

#include <assert.h>

#if defined(DMALLOC)
#include <dmalloc.h>
#endif

#include "scamper_linepoll.h"

struct scamper_linepoll
{
  scamper_linepoll_handler_t handler;
  void    *param;
  uint8_t *buf;
  size_t   len;
};

/*
 * scamper_linepoll_handle
 *
 * take the input buf and call lp->handler for each complete line it reads.
 * if the last read had an incomplete line, then merge the line together.
 */
int scamper_linepoll_handle(scamper_linepoll_t *lp, uint8_t *buf, size_t len)
{
  uint8_t *bbuf;
  size_t i = 0, s = 0, blen;

  assert(lp != NULL);
  assert(buf != NULL);

  /* make sure there is something in the buf */
  if(len < 1)
    {
      return 0;
    }

  /*
   * there is a partial line from the previous read, deal with it now.
   * it is dealt with by scanning for the actual end of the line in this
   * buffer, and then putting the two pieces together.
   */
  if(lp->len > 0)
    {
      /* scan for the end-of-line */
      while(i < len)
      {
        /* until a \n is found, keep looking */
        if(buf[i] != '\n')
          {
            i++;
            continue;
          }

        /* allocate a buffer big enough to take both segments of the line */
        if((bbuf = malloc(lp->len + i + 1)) == NULL)
          {
            return -1;
          }
        buf[i] = '\0';
        memcpy(bbuf, lp->buf, lp->len);
        memcpy(bbuf+lp->len, buf, i+1);
        blen = lp->len+i;

        /* we don't need the old buf anymore */
        free(lp->buf); lp->buf = NULL; lp->len = 0;

        /* drop the \r of a \r\n if necessary */
        if(bbuf[blen-1] == '\r')
          {
            /*
             * make sure that if the \r is dropped, we're not left with an
             * empty line
             */
            if(blen-1 > 0)
            {
              bbuf[--blen] = '\0';
              lp->handler(lp->param, bbuf, blen);
            }
          }
        else
          {
            /* blen should be > 0, as lp->len > 0 above */
            assert(blen > 0);
            lp->handler(lp->param, bbuf, blen);
          }

        free(bbuf);
        break;
      }

      /*
       * if a newline was not found then merge the two buffers together
       * and hold them for next time.
       */
      if(i == len)
      {
        /* allocate a bigger buffer */
        if((bbuf = realloc(lp->buf, lp->len + len)) == NULL)
          {
            return -1;
          }
        lp->buf = bbuf;

        /*
         * copy in additional data and then increase the record held of
         * the total length of the line so far
         */
        memcpy(lp->buf+lp->len, buf, len);
        lp->len += len;

        return 0;
      }

      s = ++i;
    }

  while(i < len)
    {
      /* skip until a new-line character is found */
      if(buf[i] != '\n')
      {
        i++;
        continue;
      }

      /*
       * if this is a blank line we don't need to pass it
       * note that if the end-of-line sequence is \r\n, then the \r is
       * stripped in addition to the \n
       */
      if(s != i)
      {
        buf[i] = '\0';
        if(buf[i-1] != '\r')
          {
            lp->handler(lp->param, buf+s, i-s);
          }
        else if(i - 1 != 0)
          {
            buf[i-1] = '\0';
            lp->handler(lp->param, buf+s, i-s-1);
          }
      }

      /* update the starting point for the next line */
      s = ++i;
    }

  if(s < len)
    {
      if((lp->buf = malloc(len - s)) == NULL)
      {
        return -1;
      }

      lp->len = len - s;
      memcpy(lp->buf, buf+s, lp->len);
    }

  return 0;
}

scamper_linepoll_t *scamper_linepoll_alloc(scamper_linepoll_handler_t handler,
                                 void *param)
{
  scamper_linepoll_t *lp;

  if((lp = malloc(sizeof(scamper_linepoll_t))) == NULL)
    {
      return NULL;
    }

  lp->handler = handler;
  lp->param = param;
  lp->buf = NULL;
  lp->len = 0;

  return lp;
}

void scamper_linepoll_free(scamper_linepoll_t *lp, int feedlastline)
{
  void *tmp;

  assert(lp != NULL);

  if(feedlastline == 1 && lp->len > 0)
    {
      if((tmp = realloc(lp->buf, lp->len+1)) != NULL)
      {
        lp->buf = tmp;
        lp->buf[lp->len] = '\0';
        lp->handler(lp->param, lp->buf, lp->len);
      }
    }

  if(lp->buf != NULL) free(lp->buf);
  free(lp);

  return;
}

Generated by  Doxygen 1.6.0   Back to index