[thirdparty/openssl.git] / ssl / packet.c

/*
 * Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include "e_os.h"
#include "packet_locl.h"

#define DEFAULT_BUF_SIZE    256

int WPACKET_allocate_bytes(WPACKET *pkt, size_t len, unsigned char **allocbytes)
{
    if (!WPACKET_reserve_bytes(pkt, len, allocbytes))
        return 0;

    pkt->written += len;
    pkt->curr += len;
    return 1;
}

int WPACKET_sub_allocate_bytes__(WPACKET *pkt, size_t len,
                                 unsigned char **allocbytes, size_t lenbytes)
{
    if (!WPACKET_start_sub_packet_len__(pkt, lenbytes)
            || !WPACKET_allocate_bytes(pkt, len, allocbytes)
            || !WPACKET_close(pkt))
        return 0;

    return 1;
}

#define GETBUF(p)   (((p)->staticbuf != NULL) \
                     ? (p)->staticbuf : (unsigned char *)(p)->buf->data)

int WPACKET_reserve_bytes(WPACKET *pkt, size_t len, unsigned char **allocbytes)
{
    /* Internal API, so should not fail */
    if (!ossl_assert(pkt->subs != NULL && len != 0))
        return 0;

    if (pkt->maxsize - pkt->written < len)
        return 0;

    if (pkt->staticbuf == NULL && (pkt->buf->length - pkt->written < len)) {
        size_t newlen;
        size_t reflen;

        reflen = (len > pkt->buf->length) ? len : pkt->buf->length;

        if (reflen > SIZE_MAX / 2) {
            newlen = SIZE_MAX;
        } else {
            newlen = reflen * 2;
            if (newlen < DEFAULT_BUF_SIZE)
                newlen = DEFAULT_BUF_SIZE;
        }
        if (BUF_MEM_grow(pkt->buf, newlen) == 0)
            return 0;
    }
    if (allocbytes != NULL)
        *allocbytes = WPACKET_get_curr(pkt);

    return 1;
}

int WPACKET_sub_reserve_bytes__(WPACKET *pkt, size_t len,
                                unsigned char **allocbytes, size_t lenbytes)
{
    if (!WPACKET_reserve_bytes(pkt, lenbytes + len, allocbytes))
        return 0;

    *allocbytes += lenbytes;

    return 1;
}

static size_t maxmaxsize(size_t lenbytes)
{
    if (lenbytes >= sizeof(size_t) || lenbytes == 0)
        return SIZE_MAX;

    return ((size_t)1 << (lenbytes * 8)) - 1 + lenbytes;
}

static int wpacket_intern_init_len(WPACKET *pkt, size_t lenbytes)
{
    unsigned char *lenchars;

    pkt->curr = 0;
    pkt->written = 0;

    pkt->subs = OPENSSL_zalloc(sizeof(*pkt->subs));
    if (pkt->subs == NULL)
        return 0;

    if (lenbytes == 0)
        return 1;

    pkt->subs->pwritten = lenbytes;
    pkt->subs->lenbytes = lenbytes;

    if (!WPACKET_allocate_bytes(pkt, lenbytes, &lenchars)) {
        OPENSSL_free(pkt->subs);
        pkt->subs = NULL;
        return 0;
    }
    pkt->subs->packet_len = lenchars - GETBUF(pkt);

    return 1;
}

int WPACKET_init_static_len(WPACKET *pkt, unsigned char *buf, size_t len,
                            size_t lenbytes)
{
    size_t max = maxmaxsize(lenbytes);

    /* Internal API, so should not fail */
    if (!ossl_assert(buf != NULL && len > 0))
        return 0;

    pkt->staticbuf = buf;
    pkt->buf = NULL;
    pkt->maxsize = (max < len) ? max : len;

    return wpacket_intern_init_len(pkt, lenbytes);
}

int WPACKET_init_len(WPACKET *pkt, BUF_MEM *buf, size_t lenbytes)
{
    /* Internal API, so should not fail */
    if (!ossl_assert(buf != NULL))
        return 0;

    pkt->staticbuf = NULL;
    pkt->buf = buf;
    pkt->maxsize = maxmaxsize(lenbytes);

    return wpacket_intern_init_len(pkt, lenbytes);
}

int WPACKET_init(WPACKET *pkt, BUF_MEM *buf)
{
    return WPACKET_init_len(pkt, buf, 0);
}

int WPACKET_set_flags(WPACKET *pkt, unsigned int flags)
{
    /* Internal API, so should not fail */
    if (!ossl_assert(pkt->subs != NULL))
        return 0;

    pkt->subs->flags = flags;

    return 1;
}

/* Store the |value| of length |len| at location |data| */
static int put_value(unsigned char *data, size_t value, size_t len)
{
    for (data += len - 1; len > 0; len--) {
        *data = (unsigned char)(value & 0xff);
        data--;
        value >>= 8;
    }

    /* Check whether we could fit the value in the assigned number of bytes */
    if (value > 0)
        return 0;

    return 1;
}


/*
 * Internal helper function used by WPACKET_close(), WPACKET_finish() and
 * WPACKET_fill_lengths() to close a sub-packet and write out its length if
 * necessary. If |doclose| is 0 then it goes through the motions of closing
 * (i.e. it fills in all the lengths), but doesn't actually close anything.
 */
static int wpacket_intern_close(WPACKET *pkt, WPACKET_SUB *sub, int doclose)
{
    size_t packlen = pkt->written - sub->pwritten;

    if (packlen == 0
            && (sub->flags & WPACKET_FLAGS_NON_ZERO_LENGTH) != 0)
        return 0;

    if (packlen == 0
            && sub->flags & WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH) {
        /* We can't handle this case. Return an error */
        if (!doclose)
            return 0;

        /* Deallocate any bytes allocated for the length of the WPACKET */
        if ((pkt->curr - sub->lenbytes) == sub->packet_len) {
            pkt->written -= sub->lenbytes;
            pkt->curr -= sub->lenbytes;
        }

        /* Don't write out the packet length */
        sub->packet_len = 0;
        sub->lenbytes = 0;
    }

    /* Write out the WPACKET length if needed */
    if (sub->lenbytes > 0
                && !put_value(&GETBUF(pkt)[sub->packet_len], packlen,
                              sub->lenbytes))
            return 0;

    if (doclose) {
        pkt->subs = sub->parent;
        OPENSSL_free(sub);
    }

    return 1;
}

int WPACKET_fill_lengths(WPACKET *pkt)
{
    WPACKET_SUB *sub;

    if (!ossl_assert(pkt->subs != NULL))
        return 0;

    for (sub = pkt->subs; sub != NULL; sub = sub->parent) {
        if (!wpacket_intern_close(pkt, sub, 0))
            return 0;
    }

    return 1;
}

int WPACKET_close(WPACKET *pkt)
{
    /*
     * Internal API, so should not fail - but we do negative testing of this
     * so no assert (otherwise the tests fail)
     */
    if (pkt->subs == NULL || pkt->subs->parent == NULL)
        return 0;

    return wpacket_intern_close(pkt, pkt->subs, 1);
}

int WPACKET_finish(WPACKET *pkt)
{
    int ret;

    /*
     * Internal API, so should not fail - but we do negative testing of this
     * so no assert (otherwise the tests fail)
     */
    if (pkt->subs == NULL || pkt->subs->parent != NULL)
        return 0;

    ret = wpacket_intern_close(pkt, pkt->subs, 1);
    if (ret) {
        OPENSSL_free(pkt->subs);
        pkt->subs = NULL;
    }

    return ret;
}

int WPACKET_start_sub_packet_len__(WPACKET *pkt, size_t lenbytes)
{
    WPACKET_SUB *sub;
    unsigned char *lenchars;

    /* Internal API, so should not fail */
    if (!ossl_assert(pkt->subs != NULL))
        return 0;

    sub = OPENSSL_zalloc(sizeof(*sub));
    if (sub == NULL)
        return 0;

    sub->parent = pkt->subs;
    pkt->subs = sub;
    sub->pwritten = pkt->written + lenbytes;
    sub->lenbytes = lenbytes;

    if (lenbytes == 0) {
        sub->packet_len = 0;
        return 1;
    }

    if (!WPACKET_allocate_bytes(pkt, lenbytes, &lenchars))
        return 0;
    /* Convert to an offset in case the underlying BUF_MEM gets realloc'd */
    sub->packet_len = lenchars - GETBUF(pkt);

    return 1;
}

int WPACKET_start_sub_packet(WPACKET *pkt)
{
    return WPACKET_start_sub_packet_len__(pkt, 0);
}

int WPACKET_put_bytes__(WPACKET *pkt, unsigned int val, size_t size)
{
    unsigned char *data;

    /* Internal API, so should not fail */
    if (!ossl_assert(size <= sizeof(unsigned int))
            || !WPACKET_allocate_bytes(pkt, size, &data)
            || !put_value(data, val, size))
        return 0;

    return 1;
}

int WPACKET_set_max_size(WPACKET *pkt, size_t maxsize)
{
    WPACKET_SUB *sub;
    size_t lenbytes;

    /* Internal API, so should not fail */
    if (!ossl_assert(pkt->subs != NULL))
        return 0;

    /* Find the WPACKET_SUB for the top level */
    for (sub = pkt->subs; sub->parent != NULL; sub = sub->parent)
        continue;

    lenbytes = sub->lenbytes;
    if (lenbytes == 0)
        lenbytes = sizeof(pkt->maxsize);

    if (maxmaxsize(lenbytes) < maxsize || maxsize < pkt->written)
        return 0;

    pkt->maxsize = maxsize;

    return 1;
}

int WPACKET_memset(WPACKET *pkt, int ch, size_t len)
{
    unsigned char *dest;

    if (len == 0)
        return 1;

    if (!WPACKET_allocate_bytes(pkt, len, &dest))
        return 0;

    memset(dest, ch, len);

    return 1;
}

int WPACKET_memcpy(WPACKET *pkt, const void *src, size_t len)
{
    unsigned char *dest;

    if (len == 0)
        return 1;

    if (!WPACKET_allocate_bytes(pkt, len, &dest))
        return 0;

    memcpy(dest, src, len);

    return 1;
}

int WPACKET_sub_memcpy__(WPACKET *pkt, const void *src, size_t len,
                         size_t lenbytes)
{
    if (!WPACKET_start_sub_packet_len__(pkt, lenbytes)
            || !WPACKET_memcpy(pkt, src, len)
            || !WPACKET_close(pkt))
        return 0;

    return 1;
}

int WPACKET_get_total_written(WPACKET *pkt, size_t *written)
{
    /* Internal API, so should not fail */
    if (!ossl_assert(written != NULL))
        return 0;

    *written = pkt->written;

    return 1;
}

int WPACKET_get_length(WPACKET *pkt, size_t *len)
{
    /* Internal API, so should not fail */
    if (!ossl_assert(pkt->subs != NULL && len != NULL))
        return 0;

    *len = pkt->written - pkt->subs->pwritten;

    return 1;
}

unsigned char *WPACKET_get_curr(WPACKET *pkt)
{
    return GETBUF(pkt) + pkt->curr;
}

void WPACKET_cleanup(WPACKET *pkt)
{
    WPACKET_SUB *sub, *parent;

    for (sub = pkt->subs; sub != NULL; sub = parent) {
        parent = sub->parent;
        OPENSSL_free(sub);
    }
    pkt->subs = NULL;
}
Commit	Line	Data
	1	/*
	2	* Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
	3	*
	4	* Licensed under the OpenSSL license (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
	8	*/
	9
	10	#include "e_os.h"
	11	#include "packet_locl.h"
	12
	13	#define DEFAULT_BUF_SIZE 256
	14
	15	int WPACKET_allocate_bytes(WPACKET pkt, size_t len, unsigned char *allocbytes)
	16	{
	17	if (!WPACKET_reserve_bytes(pkt, len, allocbytes))
	18	return 0;
	19
	20	pkt->written += len;
	21	pkt->curr += len;
	22	return 1;
	23	}
	24
	25	int WPACKET_sub_allocate_bytes__(WPACKET *pkt, size_t len,
	26	unsigned char **allocbytes, size_t lenbytes)
	27	{
	28	if (!WPACKET_start_sub_packet_len__(pkt, lenbytes)
	29	\|\| !WPACKET_allocate_bytes(pkt, len, allocbytes)
	30	\|\| !WPACKET_close(pkt))
	31	return 0;
	32
	33	return 1;
	34	}
	35
	36	#define GETBUF(p) (((p)->staticbuf != NULL) \
	37	? (p)->staticbuf : (unsigned char *)(p)->buf->data)
	38
	39	int WPACKET_reserve_bytes(WPACKET pkt, size_t len, unsigned char *allocbytes)
	40	{
	41	/* Internal API, so should not fail */
	42	if (!ossl_assert(pkt->subs != NULL && len != 0))
	43	return 0;
	44
	45	if (pkt->maxsize - pkt->written < len)
	46	return 0;
	47
	48	if (pkt->staticbuf == NULL && (pkt->buf->length - pkt->written < len)) {
	49	size_t newlen;
	50	size_t reflen;
	51
	52	reflen = (len > pkt->buf->length) ? len : pkt->buf->length;
	53
	54	if (reflen > SIZE_MAX / 2) {
	55	newlen = SIZE_MAX;
	56	} else {
	57	newlen = reflen * 2;
	58	if (newlen < DEFAULT_BUF_SIZE)
	59	newlen = DEFAULT_BUF_SIZE;
	60	}
	61	if (BUF_MEM_grow(pkt->buf, newlen) == 0)
	62	return 0;
	63	}
	64	if (allocbytes != NULL)
	65	*allocbytes = WPACKET_get_curr(pkt);
	66
	67	return 1;
	68	}
	69
	70	int WPACKET_sub_reserve_bytes__(WPACKET *pkt, size_t len,
	71	unsigned char **allocbytes, size_t lenbytes)
	72	{
	73	if (!WPACKET_reserve_bytes(pkt, lenbytes + len, allocbytes))
	74	return 0;
	75
	76	*allocbytes += lenbytes;
	77
	78	return 1;
	79	}
	80
	81	static size_t maxmaxsize(size_t lenbytes)
	82	{
	83	if (lenbytes >= sizeof(size_t) \|\| lenbytes == 0)
	84	return SIZE_MAX;
	85
	86	return ((size_t)1 << (lenbytes * 8)) - 1 + lenbytes;
	87	}
	88
	89	static int wpacket_intern_init_len(WPACKET *pkt, size_t lenbytes)
	90	{
	91	unsigned char *lenchars;
	92
	93	pkt->curr = 0;
	94	pkt->written = 0;
	95
	96	pkt->subs = OPENSSL_zalloc(sizeof(*pkt->subs));
	97	if (pkt->subs == NULL)
	98	return 0;
	99
	100	if (lenbytes == 0)
	101	return 1;
	102
	103	pkt->subs->pwritten = lenbytes;
	104	pkt->subs->lenbytes = lenbytes;
	105
	106	if (!WPACKET_allocate_bytes(pkt, lenbytes, &lenchars)) {
	107	OPENSSL_free(pkt->subs);
	108	pkt->subs = NULL;
	109	return 0;
	110	}
	111	pkt->subs->packet_len = lenchars - GETBUF(pkt);
	112
	113	return 1;
	114	}
	115
	116	int WPACKET_init_static_len(WPACKET pkt, unsigned char buf, size_t len,
	117	size_t lenbytes)
	118	{
	119	size_t max = maxmaxsize(lenbytes);
	120
	121	/* Internal API, so should not fail */
	122	if (!ossl_assert(buf != NULL && len > 0))
	123	return 0;
	124
	125	pkt->staticbuf = buf;
	126	pkt->buf = NULL;
	127	pkt->maxsize = (max < len) ? max : len;
	128
	129	return wpacket_intern_init_len(pkt, lenbytes);
	130	}
	131
	132	int WPACKET_init_len(WPACKET pkt, BUF_MEM buf, size_t lenbytes)
	133	{
	134	/* Internal API, so should not fail */
	135	if (!ossl_assert(buf != NULL))
	136	return 0;
	137
	138	pkt->staticbuf = NULL;
	139	pkt->buf = buf;
	140	pkt->maxsize = maxmaxsize(lenbytes);
	141
	142	return wpacket_intern_init_len(pkt, lenbytes);
	143	}
	144
	145	int WPACKET_init(WPACKET pkt, BUF_MEM buf)
	146	{
	147	return WPACKET_init_len(pkt, buf, 0);
	148	}
	149
	150	int WPACKET_set_flags(WPACKET *pkt, unsigned int flags)
	151	{
	152	/* Internal API, so should not fail */
	153	if (!ossl_assert(pkt->subs != NULL))
	154	return 0;
	155
	156	pkt->subs->flags = flags;
	157
	158	return 1;
	159	}
	160
	161	/* Store the \|value\| of length \|len\| at location \|data\| */
	162	static int put_value(unsigned char *data, size_t value, size_t len)
	163	{
	164	for (data += len - 1; len > 0; len--) {
	165	*data = (unsigned char)(value & 0xff);
	166	data--;
	167	value >>= 8;
	168	}
	169
	170	/* Check whether we could fit the value in the assigned number of bytes */
	171	if (value > 0)
	172	return 0;
	173
	174	return 1;
	175	}
	176
	177
	178	/*
	179	* Internal helper function used by WPACKET_close(), WPACKET_finish() and
	180	* WPACKET_fill_lengths() to close a sub-packet and write out its length if
	181	* necessary. If \|doclose\| is 0 then it goes through the motions of closing
	182	* (i.e. it fills in all the lengths), but doesn't actually close anything.
	183	*/
	184	static int wpacket_intern_close(WPACKET pkt, WPACKET_SUB sub, int doclose)
	185	{
	186	size_t packlen = pkt->written - sub->pwritten;
	187
	188	if (packlen == 0
	189	&& (sub->flags & WPACKET_FLAGS_NON_ZERO_LENGTH) != 0)
	190	return 0;
	191
	192	if (packlen == 0
	193	&& sub->flags & WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH) {
	194	/* We can't handle this case. Return an error */
	195	if (!doclose)
	196	return 0;
	197
	198	/* Deallocate any bytes allocated for the length of the WPACKET */
	199	if ((pkt->curr - sub->lenbytes) == sub->packet_len) {
	200	pkt->written -= sub->lenbytes;
	201	pkt->curr -= sub->lenbytes;
	202	}
	203
	204	/* Don't write out the packet length */
	205	sub->packet_len = 0;
	206	sub->lenbytes = 0;
	207	}
	208
	209	/* Write out the WPACKET length if needed */
	210	if (sub->lenbytes > 0
	211	&& !put_value(&GETBUF(pkt)[sub->packet_len], packlen,
	212	sub->lenbytes))
	213	return 0;
	214
	215	if (doclose) {
	216	pkt->subs = sub->parent;
	217	OPENSSL_free(sub);
	218	}
	219
	220	return 1;
	221	}
	222
	223	int WPACKET_fill_lengths(WPACKET *pkt)
	224	{
	225	WPACKET_SUB *sub;
	226
	227	if (!ossl_assert(pkt->subs != NULL))
	228	return 0;
	229
	230	for (sub = pkt->subs; sub != NULL; sub = sub->parent) {
	231	if (!wpacket_intern_close(pkt, sub, 0))
	232	return 0;
	233	}
	234
	235	return 1;
	236	}
	237
	238	int WPACKET_close(WPACKET *pkt)
	239	{
	240	/*
	241	* Internal API, so should not fail - but we do negative testing of this
	242	* so no assert (otherwise the tests fail)
	243	*/
	244	if (pkt->subs == NULL \|\| pkt->subs->parent == NULL)
	245	return 0;
	246
	247	return wpacket_intern_close(pkt, pkt->subs, 1);
	248	}
	249
	250	int WPACKET_finish(WPACKET *pkt)
	251	{
	252	int ret;
	253
	254	/*
	255	* Internal API, so should not fail - but we do negative testing of this
	256	* so no assert (otherwise the tests fail)
	257	*/
	258	if (pkt->subs == NULL \|\| pkt->subs->parent != NULL)
	259	return 0;
	260
	261	ret = wpacket_intern_close(pkt, pkt->subs, 1);
	262	if (ret) {
	263	OPENSSL_free(pkt->subs);
	264	pkt->subs = NULL;
	265	}
	266
	267	return ret;
	268	}
	269
	270	int WPACKET_start_sub_packet_len__(WPACKET *pkt, size_t lenbytes)
	271	{
	272	WPACKET_SUB *sub;
	273	unsigned char *lenchars;
	274
	275	/* Internal API, so should not fail */
	276	if (!ossl_assert(pkt->subs != NULL))
	277	return 0;
	278
	279	sub = OPENSSL_zalloc(sizeof(*sub));
	280	if (sub == NULL)
	281	return 0;
	282
	283	sub->parent = pkt->subs;
	284	pkt->subs = sub;
	285	sub->pwritten = pkt->written + lenbytes;
	286	sub->lenbytes = lenbytes;
	287
	288	if (lenbytes == 0) {
	289	sub->packet_len = 0;
	290	return 1;
	291	}
	292
	293	if (!WPACKET_allocate_bytes(pkt, lenbytes, &lenchars))
	294	return 0;
	295	/* Convert to an offset in case the underlying BUF_MEM gets realloc'd */
	296	sub->packet_len = lenchars - GETBUF(pkt);
	297
	298	return 1;
	299	}
	300
	301	int WPACKET_start_sub_packet(WPACKET *pkt)
	302	{
	303	return WPACKET_start_sub_packet_len__(pkt, 0);
	304	}
	305
	306	int WPACKET_put_bytes__(WPACKET *pkt, unsigned int val, size_t size)
	307	{
	308	unsigned char *data;
	309
	310	/* Internal API, so should not fail */
	311	if (!ossl_assert(size <= sizeof(unsigned int))
	312	\|\| !WPACKET_allocate_bytes(pkt, size, &data)
	313	\|\| !put_value(data, val, size))
	314	return 0;
	315
	316	return 1;
	317	}
	318
	319	int WPACKET_set_max_size(WPACKET *pkt, size_t maxsize)
	320	{
	321	WPACKET_SUB *sub;
	322	size_t lenbytes;
	323
	324	/* Internal API, so should not fail */
	325	if (!ossl_assert(pkt->subs != NULL))
	326	return 0;
	327
	328	/* Find the WPACKET_SUB for the top level */
	329	for (sub = pkt->subs; sub->parent != NULL; sub = sub->parent)
	330	continue;
	331
	332	lenbytes = sub->lenbytes;
	333	if (lenbytes == 0)
	334	lenbytes = sizeof(pkt->maxsize);
	335
	336	if (maxmaxsize(lenbytes) < maxsize \|\| maxsize < pkt->written)
	337	return 0;
	338
	339	pkt->maxsize = maxsize;
	340
	341	return 1;
	342	}
	343
	344	int WPACKET_memset(WPACKET *pkt, int ch, size_t len)
	345	{
	346	unsigned char *dest;
	347
	348	if (len == 0)
	349	return 1;
	350
	351	if (!WPACKET_allocate_bytes(pkt, len, &dest))
	352	return 0;
	353
	354	memset(dest, ch, len);
	355
	356	return 1;
	357	}
	358
	359	int WPACKET_memcpy(WPACKET pkt, const void src, size_t len)
	360	{
	361	unsigned char *dest;
	362
	363	if (len == 0)
	364	return 1;
	365
	366	if (!WPACKET_allocate_bytes(pkt, len, &dest))
	367	return 0;
	368
	369	memcpy(dest, src, len);
	370
	371	return 1;
	372	}
	373
	374	int WPACKET_sub_memcpy__(WPACKET pkt, const void src, size_t len,
	375	size_t lenbytes)
	376	{
	377	if (!WPACKET_start_sub_packet_len__(pkt, lenbytes)
	378	\|\| !WPACKET_memcpy(pkt, src, len)
	379	\|\| !WPACKET_close(pkt))
	380	return 0;
	381
	382	return 1;
	383	}
	384
	385	int WPACKET_get_total_written(WPACKET pkt, size_t written)
	386	{
	387	/* Internal API, so should not fail */
	388	if (!ossl_assert(written != NULL))
	389	return 0;
	390
	391	*written = pkt->written;
	392
	393	return 1;
	394	}
	395
	396	int WPACKET_get_length(WPACKET pkt, size_t len)
	397	{
	398	/* Internal API, so should not fail */
	399	if (!ossl_assert(pkt->subs != NULL && len != NULL))
	400	return 0;
	401
	402	*len = pkt->written - pkt->subs->pwritten;
	403
	404	return 1;
	405	}
	406
	407	unsigned char WPACKET_get_curr(WPACKET pkt)
	408	{
	409	return GETBUF(pkt) + pkt->curr;
	410	}
	411
	412	void WPACKET_cleanup(WPACKET *pkt)
	413	{
	414	WPACKET_SUB sub, parent;
	415
	416	for (sub = pkt->subs; sub != NULL; sub = parent) {
	417	parent = sub->parent;
	418	OPENSSL_free(sub);
	419	}
	420	pkt->subs = NULL;
	421	}