--- /dev/null
+/*
+ * 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 "packet_locl.h"
+
+/*
+ * Allocate bytes in the PACKETW_BUF for the output. This reserves the bytes
+ * and count them as "written", but doesn't actually do the writing.
+ */
+static unsigned char *PACKETW_BUF_allocate(PACKETW_BUF *wbuf, size_t len)
+{
+ unsigned char *ret = wbuf->curr;
+
+ if (SIZE_MAX - wbuf->written < len)
+ return 0;
+
+ if (wbuf->maxsize > 0 && wbuf->written + len > wbuf->maxsize)
+ return 0;
+
+ if (wbuf->buf->length - wbuf->written < len) {
+ size_t newlen;
+
+ if (wbuf->buf->length > SIZE_MAX / 2)
+ newlen = SIZE_MAX;
+ else
+ newlen = wbuf->buf->length * 2;
+ if (BUF_MEM_grow(wbuf->buf, newlen) == 0)
+ return NULL;
+ }
+ wbuf->written += len;
+ wbuf->curr += len;
+
+ return ret;
+}
+
+/*
+ * Initialise a PACKETW with the buffer in |buf|. The buffer must exist
+ * for the whole time that the PACKETW is being used. Additionally |lenbytes| of
+ * data is preallocated at the start of the buffer to store the length of the
+ * PACKETW once we know it.
+ */
+int PACKETW_init_len(PACKETW *pkt, BUF_MEM *buf, size_t lenbytes)
+{
+ PACKETW_BUF *wbuf;
+ /* Sanity check */
+ if (buf == NULL)
+ return 0;
+
+ wbuf = OPENSSL_zalloc(sizeof(PACKETW_BUF));
+ if (wbuf == NULL) {
+ pkt->isclosed = 1;
+ return 0;
+ }
+
+ wbuf->buf = buf;
+ wbuf->curr = (unsigned char *)buf->data;
+ wbuf->written = 0;
+ wbuf->maxsize = 0;
+
+ pkt->parent = NULL;
+ pkt->wbuf = wbuf;
+ pkt->pwritten = lenbytes;
+ pkt->lenbytes = lenbytes;
+ pkt->haschild = 0;
+ pkt->isclosed = 0;
+
+ if (lenbytes == 0) {
+ pkt->packet_len = NULL;
+ return 1;
+ }
+
+ pkt->packet_len = PACKETW_BUF_allocate(wbuf, lenbytes);
+ if (pkt->packet_len == NULL) {
+ OPENSSL_free(wbuf);
+ pkt->wbuf = NULL;
+ pkt->isclosed = 1;
+ return 0;
+ }
+
+ return 1;
+}
+
+/*
+ * Same as PACKETW_init_len except there is no preallocation of the PACKETW
+ * length.
+ */
+int PACKETW_init(PACKETW *pkt, BUF_MEM *buf)
+{
+ return PACKETW_init_len(pkt, buf, 0);
+}
+
+/*
+ * Set the PACKETW length, and the location for where we should write that
+ * length. Normally this will be at the start of the PACKETW, and therefore
+ * the PACKETW would have been initialised via PACKETW_init_len(). However there
+ * is the possibility that the length needs to be written to some other location
+ * other than the start of the PACKETW. In that case init via PACKETW_init() and
+ * then set the location for the length using this function.
+ */
+int PACKETW_set_packet_len(PACKETW *pkt, unsigned char *packet_len,
+ size_t lenbytes)
+{
+ /* We only allow this to be set once */
+ if (pkt->isclosed || pkt->packet_len != NULL)
+ return 0;
+
+ pkt->lenbytes = lenbytes;
+ pkt->packet_len = packet_len;
+
+ return 1;
+}
+
+int PACKETW_set_flags(PACKETW *pkt, unsigned int flags)
+{
+ pkt->flags = flags;
+
+ return 1;
+}
+
+/*
+ * Closes the PACKETW and marks it as invalid for future writes. It also writes
+ * out the length of the packet to the required location (normally the start
+ * of the PACKETW) if appropriate. A PACKETW cannot be closed if it has an
+ * active sub-packet.
+ */
+int PACKETW_close(PACKETW *pkt)
+{
+ size_t packlen;
+
+ if (pkt->isclosed || pkt->haschild)
+ return 0;
+
+ packlen = pkt->wbuf->written - pkt->pwritten;
+ if (packlen == 0 && pkt->flags & OPENSSL_PACKETW_FLAGS_NON_ZERO_LENGTH)
+ return 0;
+
+ if (packlen == 0
+ && pkt->flags & OPENSSL_PACKETW_FLAGS_ABANDON_ON_ZERO_LENGTH) {
+ /* Deallocate any bytes allocated for the length of the PACKETW */
+ if ((pkt->wbuf->curr - pkt->lenbytes) == pkt->packet_len) {
+ pkt->wbuf->written -= pkt->lenbytes;
+ pkt->wbuf->curr -= pkt->lenbytes;
+ }
+
+ /* Don't write out the packet length */
+ pkt->packet_len = NULL;
+ }
+
+ /* Write out the PACKETW length if needed */
+ if (pkt->packet_len != NULL) {
+ size_t lenbytes;
+
+ lenbytes = pkt->lenbytes;
+
+ for (; lenbytes > 0; lenbytes--) {
+ pkt->packet_len[lenbytes - 1] = (unsigned char)(packlen & 0xff);
+ packlen >>= 8;
+ }
+ if (packlen > 0) {
+ /*
+ * We've extended beyond the max allowed for the number of len bytes
+ */
+ return 0;
+ }
+ }
+
+ if (pkt->parent != NULL) {
+ if (pkt->parent->haschild != 1) {
+ /* Should not happen! */
+ return 0;
+ }
+ pkt->parent->haschild = 0;
+ pkt->parent = NULL;
+ }
+
+ pkt->isclosed = 1;
+
+ return 1;
+}
+
+/*
+ * Initialise a new sub-packet (|subpkt|), based on a parent (|pkt|).
+ * Additionally |lenbytes| of data is preallocated at the start of the
+ * sub-packet to store its length once we know it.
+ */
+int PACKETW_get_sub_packet_len(PACKETW *pkt, PACKETW *subpkt, size_t lenbytes)
+{
+ if (pkt->isclosed || pkt->haschild || subpkt == NULL)
+ return 0;
+
+ subpkt->parent = pkt;
+ subpkt->wbuf = pkt->wbuf;
+ subpkt->pwritten = pkt->wbuf->written + lenbytes;
+ subpkt->lenbytes = lenbytes;
+ subpkt->haschild = 0;
+ subpkt->isclosed = 0;
+
+ if (lenbytes == 0) {
+ subpkt->packet_len = NULL;
+ pkt->haschild = 1;
+ return 1;
+ }
+
+ subpkt->packet_len = PACKETW_BUF_allocate(pkt->wbuf, lenbytes);
+ if (subpkt->packet_len == NULL) {
+ subpkt->isclosed = 1;
+ return 0;
+ }
+
+ pkt->haschild = 1;
+
+ return 1;
+}
+
+/*
+ * Same as PACKETW_get_sub_packet_len() except no bytes are pre-allocated for
+ * the sub-packet length.
+ */
+int PACKETW_get_sub_packet(PACKETW *pkt, PACKETW *subpkt)
+{
+ return PACKETW_get_sub_packet_len(pkt, subpkt, 0);
+}
+
+/*
+ * Allocate some bytes in the PACKETW for writing. That number of bytes is
+ * marked as having been written, and a pointer to their location is stored in
+ * |*allocbytes|.
+ */
+int PACKETW_allocate_bytes(PACKETW *pkt, size_t bytes,
+ unsigned char **allocbytes)
+{
+ unsigned char *data;
+
+ if (pkt->isclosed || pkt->haschild || bytes == 0)
+ return 0;
+
+ data = PACKETW_BUF_allocate(pkt->wbuf, bytes);
+ if (data == NULL)
+ return 0;
+
+ *allocbytes = data;
+
+ return 1;
+}
+
+/*
+ * Write the value stored in |val| into the PACKETW. The value will consome
+ * |bytes| amount of storage. An error will occur if |val| cannot be accommdated
+ * in |bytes| storage, e.g. attempting to write the value 256 into 1 byte will
+ * fail.
+ */
+int PACKETW_put_bytes(PACKETW *pkt, unsigned int val, size_t bytes)
+{
+ unsigned char *data;
+
+ if (bytes > sizeof(unsigned int)
+ || !PACKETW_allocate_bytes(pkt, bytes, &data))
+ return 0;
+
+ data += bytes - 1;
+ for (; bytes > 0; bytes--) {
+ *data = (unsigned char)(val & 0xff);
+ data--;
+ val >>= 8;
+ }
+
+ /* Check whether we could fit the value in the assigned number of bytes */
+ if (val > 0)
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Set a maximum size that we will not allow the PACKETW to grow beyond. If not
+ * set then there is no maximum.
+ */
+int PACKETW_set_max_size(PACKETW *pkt, size_t maxsize)
+{
+ pkt->wbuf->maxsize = maxsize;
+
+ return 1;
+}
+
+/*
+ * Copy |len| bytes of data from |*src| into the PACKETW.
+ */
+int PACKETW_memcpy(PACKETW *pkt, const void *src, size_t len)
+{
+ unsigned char *dest;
+
+ if (len == 0)
+ return 1;
+
+ if (!PACKETW_allocate_bytes(pkt, len, &dest))
+ return 0;
+
+ memcpy(dest, src, len);
+
+ return 1;
+}
+
+/*
+ * Return the total number of bytes written so far to the underlying buffer.
+ * This might includes bytes written by a parent PACKETW.
+ */
+int PACKETW_get_total_written(PACKETW *pkt, size_t *written)
+{
+ if (pkt->isclosed || written == NULL)
+ return 0;
+
+ *written = pkt->wbuf->curr - (unsigned char *)pkt->wbuf->buf->data;
+
+ return 1;
+}
+
+/*
+ * Returns the length of this PACKETW so far. This excludes any bytes allocated
+ * for the length itself.
+ */
+int PACKETW_get_length(PACKETW *pkt, size_t *len)
+{
+ if (pkt->isclosed || len == NULL)
+ return 0;
+
+ *len = pkt->wbuf->written - pkt->pwritten;
+
+ return 1;
+}
return 1;
}
+
+/* Writeable packets */
+
+typedef struct packetw_buf {
+ /* The buffer where we store the output data */
+ BUF_MEM *buf;
+
+ /* Pointer to where we are currently writing */
+ unsigned char *curr;
+
+ /* Number of bytes written so far */
+ size_t written;
+
+ /*
+ * Maximum number of bytes we will allow to be written to this PACKETW. Zero
+ * if no maximum
+ */
+ size_t maxsize;
+} PACKETW_BUF;
+
+typedef struct packetw_st PACKETW;
+struct packetw_st {
+ /* The parent PACKETW if we have one or NULL otherwise */
+ PACKETW *parent;
+
+ /* The actual buffer - shared with sub-packets */
+ PACKETW_BUF *wbuf;
+
+ /* Flags for this PACKETW */
+ unsigned int flags;
+
+ /*
+ * Pointer to where the length of this PACKETW goes (or NULL if we don't
+ * write the length)
+ */
+ unsigned char *packet_len;
+
+ /* Number of bytes in the packet_len */
+ size_t lenbytes;
+
+ /* Number of bytes written to the buf prior to this packet starting */
+ size_t pwritten;
+
+ /* True if we have an active sub-packet or false otherwise */
+ int haschild;
+
+ /* True if PACKETW_close() has been called on this PACKETW */
+ int isclosed;
+};
+
+/* Flags */
+#define OPENSSL_PACKETW_FLAGS_NONE 0
+/* Error on PACKETW_close() if no data written to the PACKETW */
+#define OPENSSL_PACKETW_FLAGS_NON_ZERO_LENGTH 1
+/*
+ * Abandon all changes on PACKETW_close() if no data written to the PACKETW,
+ * i.e. this does not write out a zero packet length
+ */
+#define OPENSSL_PACKETW_FLAGS_ABANDON_ON_ZERO_LENGTH 2
+
+int PACKETW_init_len(PACKETW *pkt, BUF_MEM *buf, size_t lenbytes);
+int PACKETW_init(PACKETW *pkt, BUF_MEM *buf);
+int PACKETW_set_flags(PACKETW *pkt, unsigned int flags);
+int PACKETW_set_packet_len(PACKETW *pkt, unsigned char *packet_len,
+ size_t lenbytes);
+int PACKETW_close(PACKETW *pkt);
+int PACKETW_get_sub_packet_len(PACKETW *pkt, PACKETW *subpkt, size_t lenbytes);
+int PACKETW_get_sub_packet(PACKETW *pkt, PACKETW *subpkt);
+int PACKETW_allocate_bytes(PACKETW *pkt, size_t bytes,
+ unsigned char **allocbytes);
+int PACKETW_put_bytes(PACKETW *pkt, unsigned int val, size_t bytes);
+int PACKETW_set_max_size(PACKETW *pkt, size_t maxsize);
+int PACKETW_memcpy(PACKETW *pkt, const void *src, size_t len);
+int PACKETW_get_total_written(PACKETW *pkt, size_t *written);
+int PACKETW_get_length(PACKETW *pkt, size_t *len);
+
# ifdef __cplusplus
}
# endif
projects / openssl.git / commitdiff