File Coverage

inc/matrixssl-3-9-3-open/core/psbuf.c

Criterion	Covered	Total	%
statement	0	494	0.0
branch	0	230	0.0
condition			n/a
subroutine			n/a
pod			n/a
total	0	724	0.0

/**
 *      @file    psbuf.c
 *      @version 950bba4 (HEAD -> master)
 *
 *      Implementation of API for handling buffers containing binary data.
 */
/*
 *      Copyright (c) 2017 INSIDE Secure Corporation
 *      All Rights Reserved
 *
 *      The latest version of this code is available at http://www.matrixssl.org
 *
 *      This software is open source; 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 General Public License does NOT permit incorporating this software
 *      into proprietary programs.  If you are unable to comply with the GPL, a
 *      commercial license for this software may be purchased from INSIDE at
 *      http://www.insidesecure.com/
 *
 *      This program is distributed in 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
 *      http://www.gnu.org/copyleft/gpl.html
 */
/******************************************************************************/

#include
#include
#include
#include
#include
#include "coreApi.h"
#include "osdep.h"

/* Omit debug printouts. */
#define debugf(...) do { } while (0)

/* This address is indicator for static allocations pool, and does not
   need to point to any valid pool. The pool cannot be NULL, because
   NULL is reserved for "default memory pool". */
psPool_t * const psStaticAllocationsPool =
    (psPool_t *) &psStaticAllocationsPool;

void *psBufInit(psPool_t *pool, psBuf_t *buf, size_t capacity)
{
    buf->buf = psMalloc(pool, capacity);
    buf->start = buf->buf;
    buf->end = buf->start;
    buf->size = buf->buf ? capacity : 0;
    return buf->buf;
}

void psBufUninit(psPool_t *pool, psBuf_t *buf)
{
    if (pool != psStaticAllocationsPool)
    {
        psFree(buf->buf, pool);
    }
    buf->buf = NULL;
    buf->start = NULL;
    buf->end = NULL;
    buf->size = 0;
}

void *psBufDetach(psPool_t *pool, psBuf_t *buf, size_t *len_p)
{
    void *new;
    size_t len = buf->end - buf->start;

    new = psMalloc(pool, len ? len : 1);
    if (new)
    {
        memcpy(new, buf->start, len);
        *len_p = len;
    }
    psBufUninit(pool, buf);
    return new;
}

int32_t psBufFromData(psPool_t *pool, psBuf_t *buf, const void *data, size_t len)
{
    void *new = NULL;

    buf->buf = buf->start = buf->end = NULL;
    buf->size = 0;

    if (data != NULL)
    {
        new = psMalloc(pool, len ? len : 1);
        if (new != NULL)
        {
            buf->buf = buf->start = buf->end = new;
            buf->size = len;
            buf->end += len;
            memcpy(new, data, len);
        }
    }
    return new ? PS_SUCCESS : PS_MEM_FAIL;
}

int32_t psBufFromStaticData(psBuf_t *buf, const void *data, size_t len)
{
    if (!data)
    {
        len = 0;
    }
    buf->buf = buf->start = buf->end = (void *) data;
    buf->size = len;
    buf->end += len;
    return data ? PS_SUCCESS : PS_ARG_FAIL;
}

int32_t psBufEmptyFromPointerSize(psBuf_t *buf, void *data, size_t len)
{
    if (!data)
    {
        len = 0;
    }
    buf->buf = buf->start = buf->end = (void *) data;
    buf->size = len;
    return data ? PS_SUCCESS : PS_ARG_FAIL;
}

char *psBufAsHex(psPool_t *pool, const psBuf_t *buf)
{
    char *hexstr;
    size_t len = buf->end - buf->start;

    hexstr = psMalloc(pool, len * 2 + 1);
    if (hexstr)
    {
        size_t i;
        hexstr[0] = 0;
        for (i = 0; i < len; i++)
        {
            sprintf(hexstr + i * 2, "%02x", buf->start[i]);
        }
    }
    return hexstr;
}

size_t psBufGetMaxAppendSize(const psBuf_t *buf)
{
    const unsigned char *loc = buf->end;
    const unsigned char *bufend = buf->buf + buf->size;

    return bufend - loc;
}

void *psBufAppendSize(psBuf_t *buf, size_t sz)
{
    unsigned char *loc = buf->end;
    unsigned char *bufend = buf->buf + buf->size;

    if (loc + sz <= bufend)
    {
        buf->end += sz;
    }
    else
    {
        loc = NULL;
    }
    return loc;
}

void psBufReservePrepend(psBuf_t *buf, size_t sz)
{
    unsigned char *bufend = buf->buf + buf->size;
    unsigned char *loc = buf->end;

    assert(buf->start == buf->end); /* Must be done at the beginning. */

    if (loc + sz <= bufend)
    {
        buf->start += sz;
        buf->end += sz;
    }
}

size_t psBufGetMaxPrependSize(const psBuf_t *buf)
{
    return buf->start - buf->buf;
}

void *psBufGetData(psBuf_t *buf)
{
    return buf->start;
}

size_t psBufGetDataSize(const psBuf_t *buf)
{
    return buf->end - buf->start;
}

void *psBufPrependSize(psBuf_t *buf, size_t sz)
{
    if (buf->buf <= buf->start && buf->buf + sz <= buf->start)
    {
        buf->start -= sz;
        return buf->start;
    }

    return NULL;
}

void psBufNormalize(psBuf_t *buf)
{
    size_t sz = psBufGetMaxPrependSize(buf);

    if (sz > 0)
    {
        /* There is some prepend size. Delete it via memmove() that
           moves data to the beginning of the buffer. */
        memmove(buf->buf, buf->start, buf->end - buf->start);
        buf->start = buf->buf;
        buf->end -= sz;
    }
}

int32_t psBufCopyDataN(psBuf_t *buf, size_t reqLen,
    unsigned char *target, size_t *targetlen)
{
    size_t len;

    /* Compute actual processing size (the smaller of [data avail, reqLen]) */
    len = psBufGetDataSize(buf);
    if (reqLen < len)
    {
        len = reqLen;
    }

    /* Check there will be no overflow. */
    if (len > *targetlen)
    {
        *targetlen = len;
        return PS_OUTPUT_LENGTH;
    }

    /* Process copy operation + move buffer pointer. */
    memcpy(target, psBufGetData(buf), len);
    buf->start += len;
    *targetlen = len;
    return PS_SUCCESS;
}

void *psDynBufInit(psPool_t *pool, psDynBuf_t *db, size_t capacity)
{
    void *mem = psBufInit(pool, &db->buf, capacity);

    db->pool = pool;
    db->err = (mem == NULL);
    db->master = NULL;
    return mem;
}

void psDynBufUninit(psDynBuf_t *db)
{
    psBufUninit(db->pool, &db->buf);
    db->err = 0;
    db->pool = NULL;
    db->master = NULL;
}

void *psDynBufDetach(psDynBuf_t *db, size_t *len_p)
{
    void *new;

    if (db->err)
    {
        psDynBufUninit(db);
        return NULL;
    }

    new = psBufDetach(db->pool, &db->buf, len_p);
    db->pool = NULL;
    return new;
}

static
void assert_subbuf(psDynBuf_t *sub)
{
    const psDynBuf_t *db;

    /* Has master. */
    assert(sub->master != NULL);

    db = sub->master;

    /* Does not have pool */
    assert(sub->pool == NULL);

    /* The buf begin and is within master allocated data area. */
    assert(sub->buf.buf >= db->buf.start && sub->buf.buf <= db->buf.end);
    assert(sub->buf.buf + sub->buf.size >= db->buf.start &&
        sub->buf.buf + sub->buf.size <= db->buf.end);

#ifdef PSBUF_DEBUG_WITH_MEMSET
    /* For debugging: Mark head and tail visually. */
    memset(sub->buf.buf, '(', sub->buf.start - sub->buf.buf);
    memset(sub->buf.end, ')', sub->buf.buf + sub->buf.size - sub->buf.end);
#endif /* PSBUF_DEBUG_WITH_MEMSET */
}

static void *psDynBufGrow(psDynBuf_t *db, size_t head_sz, size_t tail_sz)
{
    void *alloc;
    void *loc;
    psBuf_t new;
    size_t headroom = db->buf.start - db->buf.buf;
    size_t tailroom = (db->buf.buf + db->buf.size) - db->buf.end;
    size_t filled = db->buf.end - db->buf.start;
    size_t offset;
    size_t offset_tail;

    if (db->err)
    {
        return NULL;
    }

    if (head_sz != 0 && head_sz < PS_DYNBUF_GROW)
    {
        head_sz = PS_DYNBUF_GROW;
    }
    if (tail_sz < PS_DYNBUF_GROW)
    {
        tail_sz = PS_DYNBUF_GROW;
    }

    if (db->master)
    {
        offset = db->buf.buf - db->master->buf.start;
        offset_tail = db->master->buf.end - (db->buf.buf + db->buf.size);
        debugf("Sub Grow: %zu+%zu+%zu => %zu+%zu+%zu; sub @ pos=%zd...-%zd\n",
            headroom, filled, tailroom, headroom + head_sz, filled, tailroom + tail_sz, offset, offset_tail);
        assert_subbuf(db);

#ifdef PSBUF_DEBUG_WITH_MEMSET
        /* For debugging: */
        memset(db->buf.buf, '{', headroom);
        memset(db->buf.end, '}', tailroom);
#endif /* PSBUF_DEBUG_WITH_MEMSET */

        loc = psDynBufGrow(db->master, 0, head_sz + tail_sz);
        if (loc)
        {
            db->master->buf.end += head_sz + tail_sz;
            if (offset_tail)
            {
                memmove(db->master->buf.end - offset_tail,
                    db->master->buf.end - offset_tail - head_sz - tail_sz,
                    offset_tail);
            }

            db->buf.buf = db->master->buf.start + offset;
            db->buf.start = db->buf.buf + headroom + head_sz;
            if (head_sz > 0)
            {
                memmove(db->buf.start,
                    db->buf.start - head_sz,
                    filled);
            }
            db->buf.end = db->buf.start + filled;
            db->buf.size = head_sz + headroom + filled +
                           tailroom + tail_sz;

            debugf("Sub Grown: sub @ pos=%d, %zd bytes (%zd+%zd+%zd)\n",
                (int) (db->buf.buf - db->master->buf.start),
                db->buf.size, db->buf.start - db->buf.buf,
                db->buf.end - db->buf.start, db->buf.buf + db->buf.size - db->buf.end);

#ifdef PSBUF_DEBUG_WITH_MEMSET
            /* For debugging: */
            memset(db->buf.buf, '<', head_sz + headroom);
            memset(db->buf.end, '>', tail_sz + tailroom);
#endif /* PSBUF_DEBUG_WITH_MEMSET */
        }
        else
        {
            db->err++;
        }
        assert_subbuf(db);

        return loc;
    }

    head_sz += headroom;
    tail_sz += tailroom;

    debugf("Grow: %zu+%zu+%zu => %zu+%zu+%zu\n",
        headroom, filled, tailroom, head_sz, filled, tail_sz);

    alloc = psBufInit(db->pool, &new, head_sz + filled + tail_sz);
    if (alloc)
    {
        psBufReservePrepend(&new, head_sz);
        loc = psBufAppendSize(&new, filled);
        /* Just allocated so there is space. */
        assert(loc != NULL);
        memcpy(loc, db->buf.start, filled);
        psBufUninit(db->pool, &db->buf);
        db->buf.buf = new.buf;
        db->buf.start = new.start;
        db->buf.end = new.end;
        db->buf.size = new.size;
    }
    else
    {
        db->err++;
        loc = NULL;
    }

    return loc;
}

void *psDynBufAppendSize(psDynBuf_t *db, size_t sz)
{
    unsigned char *loc = psBufAppendSize(&db->buf, sz);

    if (loc == NULL)
    {
        if (psDynBufGrow(db, 0, sz))
        {
            loc = psBufAppendSize(&db->buf, sz);
            assert(loc != NULL);
        }
    }
    return loc;
}

void *psDynBufAppendUtf8(psDynBuf_t *db, int chr)
{
    unsigned char *enc;
    unsigned int ch = (unsigned int) chr;

    /* Do not encode characters outside valid UTF-8 range. */
    if (ch > 0x1FFFF)
    {
        db->err++;
        return NULL;
    }
    if (ch < 128)
    {
        enc = psDynBufAppendSize(db, 1);
        if (enc)
        {
            *enc = (unsigned char) ch;
        }
    }
    else if (ch <= 0x7FF)
    {
        /* Two byte encoding. */
        enc = psDynBufAppendSize(db, 2);
        if (enc)
        {
            enc[0] = (unsigned char) (0xC0 | (ch >> 6));
            enc[1] = (unsigned char) (0x80 | (ch & 63));
        }
    }
    else if (ch <= 0xffff)
    {
        /* Three byte encoding. */
        enc = psDynBufAppendSize(db, 3);
        if (enc)
        {
            enc[0] = (unsigned char) (0xE0 | (ch >> 12));
            enc[1] = (unsigned char) (0x80 | ((ch >> 6) & 63));
            enc[2] = (unsigned char) (0x80 | (ch & 63));
        }
    }
    else
    {
        /* Four byte encoding. */
        enc = psDynBufAppendSize(db, 4);
        if (enc)
        {
            enc[0] = (unsigned char) (0xF0 | (ch >> 18));
            enc[1] = (unsigned char) (0x80 | ((ch >> 12) & 63));
            enc[2] = (unsigned char) (0x80 | ((ch >> 6) & 63));
            enc[3] = (unsigned char) (0x80 | (ch & 63));
        }
    }
    return enc;
}


void psDynBufReservePrepend(psDynBuf_t *db, size_t sz)
{
    /* This function only performs action if nothing has been pushed.
       The logic for prepending will make sure prepend succeeds even
       if there is no head room. */
    if (db->buf.start == db->buf.end)
    {
        psBufReservePrepend(&db->buf, sz);
    }
}

void *psDynBufPrependSize(psDynBuf_t *db, size_t sz)
{
    unsigned char *loc = psBufPrependSize(&db->buf, sz);

    if (loc == NULL)
    {
        if (psDynBufGrow(db, sz, 0))
        {
            loc = psBufPrependSize(&db->buf, sz);
            assert(loc != NULL);
        }
    }
    return loc;
}

void *psDynBufSubInit(psDynBuf_t *db, psDynBuf_t *sub, size_t capacity)
{
    void *mem = psDynBufAppendSize(db, capacity);

    if (mem)
    {
        sub->buf.buf = db->buf.end - capacity;
        sub->buf.start = sub->buf.buf;
        sub->buf.end = sub->buf.buf;
        sub->buf.size = capacity;
        sub->pool = NULL;
        sub->master = db;
        sub->err = 0;
#ifdef PSBUF_DEBUG_WITH_MEMSET
        memset(sub->buf.buf, '#', capacity);
#endif /* PSBUF_DEBUG_WITH_MEMSET */
        assert_subbuf(sub);
    }
    else
    {
        sub->buf.buf = sub->buf.start = sub->buf.end = NULL;
        sub->buf.size = 0;
        sub->pool = NULL;
        sub->err = 1;
        db->err++;
        sub->master = db;
    }

    return mem;
}

void *psDynBufSubInitAt(psDynBuf_t *db, psDynBuf_t *sub, size_t at,
    size_t length)
{
    size_t len = db->buf.end - db->buf.start;

    if (db->err == 0 && at + length <= len)
    {
        sub->buf.buf = db->buf.start + at;
        sub->buf.start = sub->buf.buf;
        sub->buf.end = sub->buf.buf;
        sub->buf.size = length;
        sub->pool = NULL;
        sub->master = db;
        sub->err = 0;
#ifdef PSBUF_DEBUG_WITH_MEMSET
        memset(sub->buf.buf, '#', length);
#endif /* PSBUF_DEBUG_WITH_MEMSET */
        assert_subbuf(sub);
    }
    else
    {
        sub->buf.buf = sub->buf.start = sub->buf.end = NULL;
        sub->buf.size = 0;
        sub->pool = NULL;
        sub->err++;
        db->err++;
        sub->master = db;
    }

    return sub->buf.buf;
}

void *psDynBufSubFinish(psDynBuf_t *sub)
{
    void *loc = NULL;
    psDynBuf_t *db = sub->master;

    if (sub->err)
    {
        db->err += sub->err;
    }
    else
    {
        size_t total = sub->buf.size;
        size_t filled = sub->buf.end - sub->buf.start;
        size_t offset_tail;

        offset_tail = db->buf.end - (sub->buf.buf + sub->buf.size);

        assert_subbuf(sub);
        if (sub->buf.buf != sub->buf.start && filled > 0)
        {
            memmove(sub->buf.buf, sub->buf.start, filled);
        }
        if (offset_tail > 0)
        {
            memmove(db->buf.end - total + filled - offset_tail,
                db->buf.end - offset_tail, offset_tail);
        }
        db->buf.end -= total;
        db->buf.end += filled;
        loc = sub->buf.buf;
    }
    sub->buf.buf = NULL;
    psDynBufUninit(sub);
    return loc;
}

static size_t len_of_tag_and_len(size_t len)
{
    size_t lentaglen;

    if (len < 128)
    {
        lentaglen = 2;
    }
    else if (len < 256)
    {
        lentaglen = 3;
    }
    else if (len < 65536)
    {
        lentaglen = 4;
    }
    else if (len < 16777216)
    {
        lentaglen = 5;
    }
    else
    {
        lentaglen = 6; /* Supports up-to 32-bit sizes. */
    }
    return lentaglen;
}

static void output_len(size_t len, unsigned char *target)
{
    if (len < 128)
    {
        target[1] = (unsigned char) len;
    }
    else if (len < 256)
    {
        target[1] = 0x81;
        target[2] = (unsigned char) len;
    }
    else if (len < 65536)
    {
        target[1] = 0x82;
        target[2] = (unsigned char) (len >> 8);
        target[3] = (unsigned char) len;
    }
    else if (len < 16777216)
    {
        target[1] = 0x83;
        target[2] = (unsigned char) (len >> 16);
        target[3] = (unsigned char) (len >> 8);
        target[4] = (unsigned char) len;
    }
    else
    {
        target[1] = 0x84;
        target[2] = (unsigned char) (len >> 24);
        target[3] = (unsigned char) (len >> 16);
        target[4] = (unsigned char) (len >> 8);
        target[5] = (unsigned char) len;
    }
}

char *psDynBufAppendAsn1TagGen(psDynBuf_t *db, unsigned char tag,
    const unsigned char *bytes, size_t len)
{
    size_t extralen = len_of_tag_and_len(len);
    unsigned char *target = psDynBufAppendSize(db, len + extralen);

    if (target)
    {
        target[0] = tag;
        output_len(len, target);
        memcpy(target + extralen, bytes, len);
    }
    return (char *) target;
}

char *psDynBufBeginConstructedTag(psDynBuf_t *db, psDynBuf_t *sub)
{
    char *target = psDynBufSubInit(db, sub, 20);

    if (target)
    {
        psDynBufReservePrepend(sub, 4);
    }
    return target;
}

char *psDynBufEndConstructedTag(psDynBuf_t *sub, unsigned char tag)
{
    size_t len = sub->buf.end - sub->buf.start;
    size_t extralen = len_of_tag_and_len(len);
    unsigned char *target = psDynBufPrependSize(sub, extralen);

    if (target)
    {
        target[0] = tag;
        output_len(len, target);
    }
    psDynBufSubFinish(sub);
    return (char *) target;
}

int32_t psParseBufFromStaticData(psParseBuf_t *pb, const void *data, size_t len)
{
    int32_t rc = psBufFromStaticData(&pb->buf, data, len);

    pb->pool = psStaticAllocationsPool;
    pb->err = rc != PS_SUCCESS;
    pb->master = NULL;
    return rc;
}

/* The maximum supported PS_PARSE_MAXIMUM_TAG_CONTENT: */
#define PS_PARSE_MAXIMUM_TAG_CONTENT 0x40000000U /* 1 gigabyte. */
/* Note: If the value needs to be extended, the limit for function
   psParseBufGetTagLen() on 32-bit hosts is 0xFFFFFFFFU - 5. */
size_t psParseBufGetTagLen(const psParseBuf_t *pb,
    unsigned char tag,
    size_t *hdrLen_p)
{
    unsigned char lenlen;
    size_t len_at = 1;
    size_t len_hdr = 2;
    size_t len_content;
    size_t len_out;
    const unsigned char *ptr = pb->buf.start;
    size_t bytes = pb->buf.end - pb->buf.start;

    if (bytes < 2)
    {
        return 0;
    }
    if (tag != 0 && ptr[0] != tag)
    {
        return 0;
    }

    /* Check size tag: long input lengths. */
    lenlen = ptr[1]; /* Use lenlen temporarily to parse length field. */
    if (lenlen >= 0x80)
    {
        if (bytes < 0x83)
        {
            return 0;
        }

        if (lenlen == 0x81 && ptr[2] < 0x80)
        {
            return 0;
        }

        if (lenlen == 0x82 && ptr[2] == 0x00)
        {
            return 0;
        }

        if (lenlen == 0x83 && ptr[2] == 0x00)
        {
            return 0;
        }

        if (lenlen == 0x84 && ptr[2] == 0x00)
        {
            return 0;
        }

        if (lenlen == 0x80 || lenlen > 0x84)
        {
            return 0; /* Too large or indefinite len. */
        }
        len_at++;
        lenlen -= 0x80;
        len_hdr += lenlen;
    }
    else
    {
        lenlen = 1;
    }

    /* len_at and lenlen now express length and of the len. */
    /* additionally, its known that all the length bytes are accessible. */
    len_content = 0;
    while (lenlen)
    {
        len_content <<= 8;
        len_content += ptr[len_at];
        len_at++;
        lenlen--;
    }

    if (len_content > PS_PARSE_MAXIMUM_TAG_CONTENT)
    {
        return 0;
    }

    len_out = len_content + len_hdr;

    if (len_out > bytes)
    {
        return 0;
    }

    if (hdrLen_p)
    {
        *hdrLen_p = len_hdr;
    }

    return len_out;
}

int psParseBufCanGetTag(const psParseBuf_t *pb, unsigned char tag)
{
    return psParseBufGetTagLen(pb, tag, NULL) > 0;
}

size_t psParseBufTrySkipBytes(psParseBuf_t *pb,
    const unsigned char *bytes,
    size_t numbytes)
{
    size_t skip_bytes = 0;

    if (psParseCanRead(pb, numbytes) &&
        memcmp(bytes, pb->buf.start, numbytes) == 0)
    {
        skip_bytes = numbytes;
    }
    pb->buf.start += skip_bytes;
    return skip_bytes;
}

size_t psParseBufSkipBytes(psParseBuf_t *pb, const unsigned char *bytes,
    size_t numbytes)
{
    size_t sz = psParseBufTrySkipBytes(pb, bytes, numbytes);

    if (sz == 0)
    {
        pb->err++;
    }
    return sz;
}

size_t psParseBufTryReadTagSub(const psParseBuf_t *pb,
    psParseBuf_t *content, unsigned char tag)
{
    size_t hdrlen;
    size_t len = psParseBufGetTagLen(pb, tag, &hdrlen);
    size_t len_content;
    psParseBuf_t content_tmp; /* Allows calling the function with
                                 content == NULL to skip the tag. */

    if (!content)
    {
        content = &content_tmp;
    }
    if (!len)
    {
        content->buf.buf = content->buf.start = content->buf.end = NULL;
        content->buf.size = 0;
        content->pool = NULL;
        /* Mark state of content as error. */
        content->err = 1;
        /* Do not raise error status of main pb. */
        content->master = (psParseBuf_t *) pb;
        return 0;
    }

    len_content = len - hdrlen;
    content->buf.start = content->buf.buf = pb->buf.start + hdrlen;
    content->buf.size = len_content;
    content->buf.end = content->buf.start + len_content;
    content->pool = NULL;
    content->master = (psParseBuf_t *) pb;
    content->err = 0;

    return len;
}

size_t psParseBufReadTagSub(psParseBuf_t *pb,
    psParseBuf_t *content, unsigned char tag)
{
    size_t len = psParseBufTryReadTagSub(pb, content, tag);

    if (len == 0)
    {
        /* Mark this also as an error in main parse buffer. */
        pb->err++;

        /* Initialize sub as the same memory than main parse buffer,
           to allow parsing using it (typically unsuccessfully)
           in following parsing operations. */
        memcpy(&(content->buf), &(pb->buf), sizeof content->buf);
    }
    return len;
}

size_t psParseBufReadTagRef(psParseBuf_t *pb,
    psBuf_t *ref, unsigned char tag)
{
    psParseBuf_t content;
    size_t len = psParseBufReadTagSub(pb, &content, tag);

    if (len)
    {
        memcpy(ref, &content.buf, sizeof(psBuf_t));
        pb->buf.start += len;
    }
    return len;
}

size_t psParseBufTrySkipTag(psParseBuf_t *pb, unsigned char tag)
{
    psParseBuf_t sub;
    size_t sz = psParseBufTryReadTagSub(pb, &sub, tag);

    if (sz)
    {
        (void) psParseBufFinish(&sub);
    }
    return sz;
}

size_t psParseBufSkipTag(psParseBuf_t *pb, unsigned char tag)
{
    psParseBuf_t sub;
    size_t sz = psParseBufReadTagSub(pb, &sub, tag);

    if (sz)
    {
        (void) psParseBufFinish(&sub);
    }
    return sz;
}

int32_t psParseBufCopyAll(const psParseBuf_t *pb, unsigned char *target,
    size_t *targetlen)
{
    size_t len = pb->buf.end - pb->buf.start;

    if (pb->err != 0)
    {
        return PS_FAILURE;
    }

    if (target == NULL)
    {
        *targetlen = len;
        return PS_OUTPUT_LENGTH;
    }

    if (len > *targetlen)
    {
        *targetlen = len;
        return PS_OUTPUT_LENGTH;
    }

    memcpy(target, pb->buf.start, len);
    *targetlen = len;
    return PS_SUCCESS;
}

int32_t psParseBufCopyN(const psParseBuf_t *pb, size_t reqLen,
    unsigned char *target, size_t *targetlen)
{
    size_t len = pb->buf.end - pb->buf.start;

    if (pb->err != 0)
    {
        return PS_FAILURE;
    }

    if (reqLen > len)
    {
        reqLen = len;
    }

    if (target == NULL)
    {
        *targetlen = reqLen;
        return PS_OUTPUT_LENGTH;
    }

    if (reqLen > *targetlen)
    {
        *targetlen = reqLen;
        return PS_OUTPUT_LENGTH;
    }

    memcpy(target, pb->buf.start, reqLen);
    *targetlen = reqLen;
    return PS_SUCCESS;
}

int32_t psParseBufCopyUntilByte(psParseBuf_t *pb, unsigned char stopbyte,
    unsigned char *target, size_t *targetlen)
{
    const unsigned char *end;
    size_t len;

    if (pb->err != 0)
    {
        return PS_FAILURE;
    }

    end = memchr(pb->buf.start, stopbyte, pb->buf.end - pb->buf.start);

    if (end == NULL)
    {
        return PS_FAILURE;
    }

    len = (end - pb->buf.start) + 1;
    return psParseBufCopyN(pb, len, target, targetlen);
}

int psParseBufEq(const psParseBuf_t *pb1, const psParseBuf_t *pb2)
{
    if (pb1->err || pb2->err)
    {
        return 0;
    }

    return psBufEq(&pb1->buf, &pb2->buf);
}

int32_t psParseBufCheckState(const psParseBuf_t *pb)
{
    return pb->err == 0 ? PS_SUCCESS : PS_FAILURE;
}

int32_t psParseBufFinish(psParseBuf_t *pb)
{
    int32_t rc;

    if (pb->master)
    {
        if (pb->err)
        {
            /* Signal master on error. */
            pb->master->err++;
        }
        else
        {
            /* Advance master. */
            pb->master->buf.start = pb->buf.buf + pb->buf.size;
        }

        pb->buf.buf = NULL; /* Do not free any data. */
    }

    /* Free state. */
    rc = psParseBufCheckState(pb);
    psBufUninit(pb->pool, &pb->buf);
    pb->master = NULL;
    pb->err = 0;
    pb->pool = NULL;
    return rc;
}

void psParseBufCancel(psParseBuf_t *pb)
{
    /* Free state. */
    if (pb->master)
    {
        pb->buf.buf = NULL; /* Do not free any data. */
    }
    psBufUninit(pb->pool, &pb->buf);
    pb->master = NULL;
    pb->err = 0;
    pb->pool = NULL;
}

/* end of file psbuf.c */