Rename PACKETW to WPACKET (ae2f7b37) · Commits · CYBER - Cyber Security / TS 103 523 MSP / TLMSP / TLMSP OpenSSL

ssl/packet.c

+45 −45

Original line number	Original line	Diff line number	Diff line
	@@ -10,10 +10,10 @@
	#include "packet_locl.h"		#include "packet_locl.h"

	/*		/*
	* Allocate bytes in the PACKETW_BUF for the output. This reserves the bytes		* Allocate bytes in the WPACKET_BUF for the output. This reserves the bytes
	* and count them as "written", but doesn't actually do the writing.		* and count them as "written", but doesn't actually do the writing.
	*/		*/
	static unsigned char PACKETW_BUF_allocate(PACKETW_BUF wbuf, size_t len)		static unsigned char WPACKET_BUF_allocate(WPACKET_BUF wbuf, size_t len)
	{		{
	unsigned char *ret = wbuf->curr;		unsigned char *ret = wbuf->curr;

	@@ -40,19 +40,19 @@ static unsigned char PACKETW_BUF_allocate(PACKETW_BUF wbuf, size_t len)
	}		}

	/*		/*
	* Initialise a PACKETW with the buffer in \|buf\|. The buffer must exist		* Initialise a WPACKET with the buffer in \|buf\|. The buffer must exist
	* for the whole time that the PACKETW is being used. Additionally \|lenbytes\| of		* for the whole time that the WPACKET is being used. Additionally \|lenbytes\| of
	* data is preallocated at the start of the buffer to store the length of the		* data is preallocated at the start of the buffer to store the length of the
	* PACKETW once we know it.		* WPACKET once we know it.
	*/		*/
	int PACKETW_init_len(PACKETW pkt, BUF_MEM buf, size_t lenbytes)		int WPACKET_init_len(WPACKET pkt, BUF_MEM buf, size_t lenbytes)
	{		{
	PACKETW_BUF *wbuf;		WPACKET_BUF *wbuf;
	/* Sanity check */		/* Sanity check */
	if (buf == NULL)		if (buf == NULL)
	return 0;		return 0;

	wbuf = OPENSSL_zalloc(sizeof(PACKETW_BUF));		wbuf = OPENSSL_zalloc(sizeof(WPACKET_BUF));
	if (wbuf == NULL) {		if (wbuf == NULL) {
	pkt->isclosed = 1;		pkt->isclosed = 1;
	return 0;		return 0;
	@@ -75,7 +75,7 @@ int PACKETW_init_len(PACKETW pkt, BUF_MEM buf, size_t lenbytes)
	return 1;		return 1;
	}		}

	pkt->packet_len = PACKETW_BUF_allocate(wbuf, lenbytes);		pkt->packet_len = WPACKET_BUF_allocate(wbuf, lenbytes);
	if (pkt->packet_len == NULL) {		if (pkt->packet_len == NULL) {
	OPENSSL_free(wbuf);		OPENSSL_free(wbuf);
	pkt->wbuf = NULL;		pkt->wbuf = NULL;
	@@ -87,23 +87,23 @@ int PACKETW_init_len(PACKETW pkt, BUF_MEM buf, size_t lenbytes)
	}		}

	/*		/*
	* Same as PACKETW_init_len except there is no preallocation of the PACKETW		* Same as WPACKET_init_len except there is no preallocation of the WPACKET
	* length.		* length.
	*/		*/
	int PACKETW_init(PACKETW pkt, BUF_MEM buf)		int WPACKET_init(WPACKET pkt, BUF_MEM buf)
	{		{
	return PACKETW_init_len(pkt, buf, 0);		return WPACKET_init_len(pkt, buf, 0);
	}		}

	/*		/*
	* Set the PACKETW length, and the location for where we should write that		* Set the WPACKET length, and the location for where we should write that
	* length. Normally this will be at the start of the PACKETW, and therefore		* length. Normally this will be at the start of the WPACKET, and therefore
	* the PACKETW would have been initialised via PACKETW_init_len(). However there		* the WPACKET would have been initialised via WPACKET_init_len(). However there
	* is the possibility that the length needs to be written to some other location		* 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		* other than the start of the WPACKET. In that case init via WPACKET_init() and
	* then set the location for the length using this function.		* then set the location for the length using this function.
	*/		*/
	int PACKETW_set_packet_len(PACKETW pkt, unsigned char packet_len,		int WPACKET_set_packet_len(WPACKET pkt, unsigned char packet_len,
	size_t lenbytes)		size_t lenbytes)
	{		{
	/* We only allow this to be set once */		/* We only allow this to be set once */
	@@ -116,7 +116,7 @@ int PACKETW_set_packet_len(PACKETW pkt, unsigned char packet_len,
	return 1;		return 1;
	}		}

	int PACKETW_set_flags(PACKETW *pkt, unsigned int flags)		int WPACKET_set_flags(WPACKET *pkt, unsigned int flags)
	{		{
	pkt->flags = flags;		pkt->flags = flags;

	@@ -124,12 +124,12 @@ int PACKETW_set_flags(PACKETW *pkt, unsigned int flags)
	}		}

	/*		/*
	* Closes the PACKETW and marks it as invalid for future writes. It also writes		* Closes the WPACKET and marks it as invalid for future writes. It also writes
	* out the length of the packet to the required location (normally the start		* 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		* of the WPACKET) if appropriate. A WPACKET cannot be closed if it has an
	* active sub-packet.		* active sub-packet.
	*/		*/
	int PACKETW_close(PACKETW *pkt)		int WPACKET_close(WPACKET *pkt)
	{		{
	size_t packlen;		size_t packlen;

	@@ -137,12 +137,12 @@ int PACKETW_close(PACKETW *pkt)
	return 0;		return 0;

	packlen = pkt->wbuf->written - pkt->pwritten;		packlen = pkt->wbuf->written - pkt->pwritten;
	if (packlen == 0 && pkt->flags & OPENSSL_PACKETW_FLAGS_NON_ZERO_LENGTH)		if (packlen == 0 && pkt->flags & OPENSSL_WPACKET_FLAGS_NON_ZERO_LENGTH)
	return 0;		return 0;

	if (packlen == 0		if (packlen == 0
	&& pkt->flags & OPENSSL_PACKETW_FLAGS_ABANDON_ON_ZERO_LENGTH) {		&& pkt->flags & OPENSSL_WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH) {
	/* Deallocate any bytes allocated for the length of the PACKETW */		/* Deallocate any bytes allocated for the length of the WPACKET */
	if ((pkt->wbuf->curr - pkt->lenbytes) == pkt->packet_len) {		if ((pkt->wbuf->curr - pkt->lenbytes) == pkt->packet_len) {
	pkt->wbuf->written -= pkt->lenbytes;		pkt->wbuf->written -= pkt->lenbytes;
	pkt->wbuf->curr -= pkt->lenbytes;		pkt->wbuf->curr -= pkt->lenbytes;
	@@ -152,7 +152,7 @@ int PACKETW_close(PACKETW *pkt)
	pkt->packet_len = NULL;		pkt->packet_len = NULL;
	}		}

	/* Write out the PACKETW length if needed */		/* Write out the WPACKET length if needed */
	if (pkt->packet_len != NULL) {		if (pkt->packet_len != NULL) {
	size_t lenbytes;		size_t lenbytes;

	@@ -189,7 +189,7 @@ int PACKETW_close(PACKETW *pkt)
	* Additionally \|lenbytes\| of data is preallocated at the start of the		* Additionally \|lenbytes\| of data is preallocated at the start of the
	* sub-packet to store its length once we know it.		* sub-packet to store its length once we know it.
	*/		*/
	int PACKETW_get_sub_packet_len(PACKETW pkt, PACKETW subpkt, size_t lenbytes)		int WPACKET_get_sub_packet_len(WPACKET pkt, WPACKET subpkt, size_t lenbytes)
	{		{
	if (pkt->isclosed \|\| pkt->haschild \|\| subpkt == NULL)		if (pkt->isclosed \|\| pkt->haschild \|\| subpkt == NULL)
	return 0;		return 0;
	@@ -207,7 +207,7 @@ int PACKETW_get_sub_packet_len(PACKETW pkt, PACKETW subpkt, size_t lenbytes)
	return 1;		return 1;
	}		}

	subpkt->packet_len = PACKETW_BUF_allocate(pkt->wbuf, lenbytes);		subpkt->packet_len = WPACKET_BUF_allocate(pkt->wbuf, lenbytes);
	if (subpkt->packet_len == NULL) {		if (subpkt->packet_len == NULL) {
	subpkt->isclosed = 1;		subpkt->isclosed = 1;
	return 0;		return 0;
	@@ -219,20 +219,20 @@ int PACKETW_get_sub_packet_len(PACKETW pkt, PACKETW subpkt, size_t lenbytes)
	}		}

	/*		/*
	* Same as PACKETW_get_sub_packet_len() except no bytes are pre-allocated for		* Same as WPACKET_get_sub_packet_len() except no bytes are pre-allocated for
	* the sub-packet length.		* the sub-packet length.
	*/		*/
	int PACKETW_get_sub_packet(PACKETW pkt, PACKETW subpkt)		int WPACKET_get_sub_packet(WPACKET pkt, WPACKET subpkt)
	{		{
	return PACKETW_get_sub_packet_len(pkt, subpkt, 0);		return WPACKET_get_sub_packet_len(pkt, subpkt, 0);
	}		}

	/*		/*
	* Allocate some bytes in the PACKETW for writing. That number of bytes is		* Allocate some bytes in the WPACKET for writing. That number of bytes is
	* marked as having been written, and a pointer to their location is stored in		* marked as having been written, and a pointer to their location is stored in
	* \|*allocbytes\|.		* \|*allocbytes\|.
	*/		*/
	int PACKETW_allocate_bytes(PACKETW *pkt, size_t bytes,		int WPACKET_allocate_bytes(WPACKET *pkt, size_t bytes,
	unsigned char **allocbytes)		unsigned char **allocbytes)
	{		{
	unsigned char *data;		unsigned char *data;
	@@ -240,7 +240,7 @@ int PACKETW_allocate_bytes(PACKETW *pkt, size_t bytes,
	if (pkt->isclosed \|\| pkt->haschild \|\| bytes == 0)		if (pkt->isclosed \|\| pkt->haschild \|\| bytes == 0)
	return 0;		return 0;

	data = PACKETW_BUF_allocate(pkt->wbuf, bytes);		data = WPACKET_BUF_allocate(pkt->wbuf, bytes);
	if (data == NULL)		if (data == NULL)
	return 0;		return 0;

	@@ -250,17 +250,17 @@ int PACKETW_allocate_bytes(PACKETW *pkt, size_t bytes,
	}		}

	/*		/*
	* Write the value stored in \|val\| into the PACKETW. The value will consome		* Write the value stored in \|val\| into the WPACKET. The value will consome
	* \|bytes\| amount of storage. An error will occur if \|val\| cannot be accommdated		* \|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		* in \|bytes\| storage, e.g. attempting to write the value 256 into 1 byte will
	* fail.		* fail.
	*/		*/
	int PACKETW_put_bytes(PACKETW *pkt, unsigned int val, size_t bytes)		int WPACKET_put_bytes(WPACKET *pkt, unsigned int val, size_t bytes)
	{		{
	unsigned char *data;		unsigned char *data;

	if (bytes > sizeof(unsigned int)		if (bytes > sizeof(unsigned int)
	\|\| !PACKETW_allocate_bytes(pkt, bytes, &data))		\|\| !WPACKET_allocate_bytes(pkt, bytes, &data))
	return 0;		return 0;

	data += bytes - 1;		data += bytes - 1;
	@@ -278,10 +278,10 @@ int PACKETW_put_bytes(PACKETW *pkt, unsigned int val, size_t bytes)
	}		}

	/*		/*
	* Set a maximum size that we will not allow the PACKETW to grow beyond. If not		* Set a maximum size that we will not allow the WPACKET to grow beyond. If not
	* set then there is no maximum.		* set then there is no maximum.
	*/		*/
	int PACKETW_set_max_size(PACKETW *pkt, size_t maxsize)		int WPACKET_set_max_size(WPACKET *pkt, size_t maxsize)
	{		{
	pkt->wbuf->maxsize = maxsize;		pkt->wbuf->maxsize = maxsize;

	@@ -289,16 +289,16 @@ int PACKETW_set_max_size(PACKETW *pkt, size_t maxsize)
	}		}

	/*		/*
	* Copy \|len\| bytes of data from \|*src\| into the PACKETW.		* Copy \|len\| bytes of data from \|*src\| into the WPACKET.
	*/		*/
	int PACKETW_memcpy(PACKETW pkt, const void src, size_t len)		int WPACKET_memcpy(WPACKET pkt, const void src, size_t len)
	{		{
	unsigned char *dest;		unsigned char *dest;

	if (len == 0)		if (len == 0)
	return 1;		return 1;

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

	memcpy(dest, src, len);		memcpy(dest, src, len);
	@@ -308,9 +308,9 @@ int PACKETW_memcpy(PACKETW pkt, const void src, size_t len)

	/*		/*
	* Return the total number of bytes written so far to the underlying buffer.		* Return the total number of bytes written so far to the underlying buffer.
	* This might includes bytes written by a parent PACKETW.		* This might includes bytes written by a parent WPACKET.
	*/		*/
	int PACKETW_get_total_written(PACKETW pkt, size_t written)		int WPACKET_get_total_written(WPACKET pkt, size_t written)
	{		{
	if (pkt->isclosed \|\| written == NULL)		if (pkt->isclosed \|\| written == NULL)
	return 0;		return 0;
	@@ -321,10 +321,10 @@ int PACKETW_get_total_written(PACKETW pkt, size_t written)
	}		}

	/*		/*
	* Returns the length of this PACKETW so far. This excludes any bytes allocated		* Returns the length of this WPACKET so far. This excludes any bytes allocated
	* for the length itself.		* for the length itself.
	*/		*/
	int PACKETW_get_length(PACKETW pkt, size_t len)		int WPACKET_get_length(WPACKET pkt, size_t len)
	{		{
	if (pkt->isclosed \|\| len == NULL)		if (pkt->isclosed \|\| len == NULL)
	return 0;		return 0;

ssl/packet_locl.h

+27 −27

Original line number	Original line	Diff line number	Diff line
	@@ -562,25 +562,25 @@ typedef struct packetw_buf {
	size_t written;		size_t written;

	/*		/*
	* Maximum number of bytes we will allow to be written to this PACKETW. Zero		* Maximum number of bytes we will allow to be written to this WPACKET. Zero
	* if no maximum		* if no maximum
	*/		*/
	size_t maxsize;		size_t maxsize;
	} PACKETW_BUF;		} WPACKET_BUF;

	typedef struct packetw_st PACKETW;		typedef struct packetw_st WPACKET;
	struct packetw_st {		struct packetw_st {
	/* The parent PACKETW if we have one or NULL otherwise */		/* The parent WPACKET if we have one or NULL otherwise */
	PACKETW *parent;		WPACKET *parent;

	/* The actual buffer - shared with sub-packets */		/* The actual buffer - shared with sub-packets */
	PACKETW_BUF *wbuf;		WPACKET_BUF *wbuf;

	/* Flags for this PACKETW */		/* Flags for this WPACKET */
	unsigned int flags;		unsigned int flags;

	/*		/*
	* Pointer to where the length of this PACKETW goes (or NULL if we don't		* Pointer to where the length of this WPACKET goes (or NULL if we don't
	* write the length)		* write the length)
	*/		*/
	unsigned char *packet_len;		unsigned char *packet_len;
	@@ -594,35 +594,35 @@ struct packetw_st {
	/* True if we have an active sub-packet or false otherwise */		/* True if we have an active sub-packet or false otherwise */
	int haschild;		int haschild;

	/* True if PACKETW_close() has been called on this PACKETW */		/* True if WPACKET_close() has been called on this WPACKET */
	int isclosed;		int isclosed;
	};		};

	/* Flags */		/* Flags */
	#define OPENSSL_PACKETW_FLAGS_NONE 0		#define OPENSSL_WPACKET_FLAGS_NONE 0
	/* Error on PACKETW_close() if no data written to the PACKETW */		/* Error on WPACKET_close() if no data written to the WPACKET */
	#define OPENSSL_PACKETW_FLAGS_NON_ZERO_LENGTH 1		#define OPENSSL_WPACKET_FLAGS_NON_ZERO_LENGTH 1
	/*		/*
	* Abandon all changes on PACKETW_close() if no data written to the PACKETW,		* Abandon all changes on WPACKET_close() if no data written to the WPACKET,
	* i.e. this does not write out a zero packet length		* i.e. this does not write out a zero packet length
	*/		*/
	#define OPENSSL_PACKETW_FLAGS_ABANDON_ON_ZERO_LENGTH 2		#define OPENSSL_WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH 2

	int PACKETW_init_len(PACKETW pkt, BUF_MEM buf, size_t lenbytes);		int WPACKET_init_len(WPACKET pkt, BUF_MEM buf, size_t lenbytes);
	int PACKETW_init(PACKETW pkt, BUF_MEM buf);		int WPACKET_init(WPACKET pkt, BUF_MEM buf);
	int PACKETW_set_flags(PACKETW *pkt, unsigned int flags);		int WPACKET_set_flags(WPACKET *pkt, unsigned int flags);
	int PACKETW_set_packet_len(PACKETW pkt, unsigned char packet_len,		int WPACKET_set_packet_len(WPACKET pkt, unsigned char packet_len,
	size_t lenbytes);		size_t lenbytes);
	int PACKETW_close(PACKETW *pkt);		int WPACKET_close(WPACKET *pkt);
	int PACKETW_get_sub_packet_len(PACKETW pkt, PACKETW subpkt, size_t lenbytes);		int WPACKET_get_sub_packet_len(WPACKET pkt, WPACKET subpkt, size_t lenbytes);
	int PACKETW_get_sub_packet(PACKETW pkt, PACKETW subpkt);		int WPACKET_get_sub_packet(WPACKET pkt, WPACKET subpkt);
	int PACKETW_allocate_bytes(PACKETW *pkt, size_t bytes,		int WPACKET_allocate_bytes(WPACKET *pkt, size_t bytes,
	unsigned char **allocbytes);		unsigned char **allocbytes);
	int PACKETW_put_bytes(PACKETW *pkt, unsigned int val, size_t bytes);		int WPACKET_put_bytes(WPACKET *pkt, unsigned int val, size_t bytes);
	int PACKETW_set_max_size(PACKETW *pkt, size_t maxsize);		int WPACKET_set_max_size(WPACKET *pkt, size_t maxsize);
	int PACKETW_memcpy(PACKETW pkt, const void src, size_t len);		int WPACKET_memcpy(WPACKET pkt, const void src, size_t len);
	int PACKETW_get_total_written(PACKETW pkt, size_t written);		int WPACKET_get_total_written(WPACKET pkt, size_t written);
	int PACKETW_get_length(PACKETW pkt, size_t len);		int WPACKET_get_length(WPACKET pkt, size_t len);

	# ifdef __cplusplus		# ifdef __cplusplus
	}		}

ssl/s3_lib.c

+7 −7

Original line number	Original line	Diff line number	Diff line
	@@ -2790,16 +2790,16 @@ int ssl3_set_handshake_header(SSL *s, int htype, unsigned long len)
	}		}

	/*		/*
	* Temporary name. To be renamed ssl3_set_handshake_header() once all PACKETW		* Temporary name. To be renamed ssl3_set_handshake_header() once all WPACKET
	* conversion is complete. The old ssl3_set_handshake_heder() can be deleted		* conversion is complete. The old ssl3_set_handshake_heder() can be deleted
	* at that point.		* at that point.
	* TODO - RENAME ME		* TODO - RENAME ME
	*/		*/
	int ssl3_set_handshake_header2(SSL s, PACKETW pkt, PACKETW *body, int htype)		int ssl3_set_handshake_header2(SSL s, WPACKET pkt, WPACKET *body, int htype)
	{		{
	/* Set the content type and 3 bytes for the message len */		/* Set the content type and 3 bytes for the message len */
	if (!PACKETW_put_bytes(pkt, htype, 1)		if (!WPACKET_put_bytes(pkt, htype, 1)
	\|\| !PACKETW_get_sub_packet_len(pkt, body, 3))		\|\| !WPACKET_get_sub_packet_len(pkt, body, 3))
	return 0;		return 0;

	return 1;		return 1;
	@@ -3573,7 +3573,7 @@ const SSL_CIPHER ssl3_get_cipher_by_char(const unsigned char p)

	/*		/*
	* Old version of the ssl3_put_cipher_by_char function used by code that has not		* Old version of the ssl3_put_cipher_by_char function used by code that has not
	* yet been converted to PACKETW yet. It will be deleted once PACKETW conversion		* yet been converted to WPACKET yet. It will be deleted once WPACKET conversion
	* is complete.		* is complete.
	* TODO - DELETE ME		* TODO - DELETE ME
	*/		*/
	@@ -3591,14 +3591,14 @@ int ssl3_put_cipher_by_char_old(const SSL_CIPHER c, unsigned char p)
	return (2);		return (2);
	}		}

	int ssl3_put_cipher_by_char(const SSL_CIPHER c, PACKETW pkt, size_t *len)		int ssl3_put_cipher_by_char(const SSL_CIPHER c, WPACKET pkt, size_t *len)
	{		{
	if ((c->id & 0xff000000) != 0x03000000) {		if ((c->id & 0xff000000) != 0x03000000) {
	*len = 0;		*len = 0;
	return 1;		return 1;
	}		}

	if (!PACKETW_put_bytes(pkt, c->id & 0xffff, 2))		if (!WPACKET_put_bytes(pkt, c->id & 0xffff, 2))
	return 0;		return 0;

	*len = 2;		*len = 2;

ssl/ssl_locl.h

+11 −11

ssl/statem/statem_clnt.c

+23 −23

Original line number	Original line	Diff line number	Diff line
	@@ -63,7 +63,7 @@ static ossl_inline int cert_req_allowed(SSL *s);
	static int key_exchange_expected(SSL *s);		static int key_exchange_expected(SSL *s);
	static int ca_dn_cmp(const X509_NAME const a, const X509_NAME const b);		static int ca_dn_cmp(const X509_NAME const a, const X509_NAME const b);
	static int ssl_cipher_list_to_bytes(SSL s, STACK_OF(SSL_CIPHER) sk,		static int ssl_cipher_list_to_bytes(SSL s, STACK_OF(SSL_CIPHER) sk,
	PACKETW *pkt);		WPACKET *pkt);

	/*		/*
	* Is a CertificateRequest message allowed at the moment or not?		* Is a CertificateRequest message allowed at the moment or not?
	@@ -697,10 +697,10 @@ int tls_construct_client_hello(SSL *s)
	SSL_COMP *comp;		SSL_COMP *comp;
	#endif		#endif
	SSL_SESSION *sess = s->session;		SSL_SESSION *sess = s->session;
	PACKETW pkt, body, spkt;		WPACKET pkt, body, spkt;

	if (!PACKETW_init(&pkt, s->init_buf)		if (!WPACKET_init(&pkt, s->init_buf)
	\|\| !PACKETW_set_max_size(&pkt, SSL3_RT_MAX_PLAIN_LENGTH)) {		\|\| !WPACKET_set_max_size(&pkt, SSL3_RT_MAX_PLAIN_LENGTH)) {
	/* Should not happen */		/* Should not happen */
	SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);		SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
	goto err;		goto err;
	@@ -782,8 +782,8 @@ int tls_construct_client_hello(SSL *s)
	* client_version in client hello and not resetting it to		* client_version in client hello and not resetting it to
	* the negotiated version.		* the negotiated version.
	*/		*/
	if (!PACKETW_put_bytes(&body, s->client_version, 2)		if (!WPACKET_put_bytes(&body, s->client_version, 2)
	\|\| !PACKETW_memcpy(&body, s->s3->client_random, SSL3_RANDOM_SIZE)) {		\|\| !WPACKET_memcpy(&body, s->s3->client_random, SSL3_RANDOM_SIZE)) {
	SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);		SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
	goto err;		goto err;
	}		}
	@@ -794,9 +794,9 @@ int tls_construct_client_hello(SSL *s)
	else		else
	i = s->session->session_id_length;		i = s->session->session_id_length;
	if (i > (int)sizeof(s->session->session_id)		if (i > (int)sizeof(s->session->session_id)
	\|\| !PACKETW_get_sub_packet_len(&body, &spkt, 1)		\|\| !WPACKET_get_sub_packet_len(&body, &spkt, 1)
	\|\| (i != 0 && !PACKETW_memcpy(&spkt, s->session->session_id, i))		\|\| (i != 0 && !WPACKET_memcpy(&spkt, s->session->session_id, i))
	\|\| !PACKETW_close(&spkt)) {		\|\| !WPACKET_close(&spkt)) {
	SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);		SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
	goto err;		goto err;
	}		}
	@@ -804,29 +804,29 @@ int tls_construct_client_hello(SSL *s)
	/* cookie stuff for DTLS */		/* cookie stuff for DTLS */
	if (SSL_IS_DTLS(s)) {		if (SSL_IS_DTLS(s)) {
	if (s->d1->cookie_len > sizeof(s->d1->cookie)		if (s->d1->cookie_len > sizeof(s->d1->cookie)
	\|\| !PACKETW_get_sub_packet_len(&body, &spkt, 1)		\|\| !WPACKET_get_sub_packet_len(&body, &spkt, 1)
	\|\| !PACKETW_memcpy(&spkt, s->d1->cookie, s->d1->cookie_len)		\|\| !WPACKET_memcpy(&spkt, s->d1->cookie, s->d1->cookie_len)
	\|\| !PACKETW_close(&spkt)) {		\|\| !WPACKET_close(&spkt)) {
	SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);		SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
	goto err;		goto err;
	}		}
	}		}

	/* Ciphers supported */		/* Ciphers supported */
	if (!PACKETW_get_sub_packet_len(&body, &spkt, 2)) {		if (!WPACKET_get_sub_packet_len(&body, &spkt, 2)) {
	SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);		SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
	goto err;		goto err;
	}		}
	/* ssl_cipher_list_to_bytes() raises SSLerr if appropriate */		/* ssl_cipher_list_to_bytes() raises SSLerr if appropriate */
	if (!ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), &spkt))		if (!ssl_cipher_list_to_bytes(s, SSL_get_ciphers(s), &spkt))
	goto err;		goto err;
	if (!PACKETW_close(&spkt)) {		if (!WPACKET_close(&spkt)) {
	SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);		SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
	goto err;		goto err;
	}		}

	/* COMPRESSION */		/* COMPRESSION */
	if (!PACKETW_get_sub_packet_len(&body, &spkt, 1)) {		if (!WPACKET_get_sub_packet_len(&body, &spkt, 1)) {
	SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);		SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
	goto err;		goto err;
	}		}
	@@ -835,7 +835,7 @@ int tls_construct_client_hello(SSL *s)
	int compnum = sk_SSL_COMP_num(s->ctx->comp_methods);		int compnum = sk_SSL_COMP_num(s->ctx->comp_methods);
	for (i = 0; i < compnum; i++) {		for (i = 0; i < compnum; i++) {
	comp = sk_SSL_COMP_value(s->ctx->comp_methods, i);		comp = sk_SSL_COMP_value(s->ctx->comp_methods, i);
	if (!PACKETW_put_bytes(&spkt, comp->id, 1)) {		if (!WPACKET_put_bytes(&spkt, comp->id, 1)) {
	SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);		SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
	goto err;		goto err;
	}		}
	@@ -843,7 +843,7 @@ int tls_construct_client_hello(SSL *s)
	}		}
	#endif		#endif
	/* Add the NULL method */		/* Add the NULL method */
	if (!PACKETW_put_bytes(&spkt, 0, 1) \|\| !PACKETW_close(&spkt)) {		if (!WPACKET_put_bytes(&spkt, 0, 1) \|\| !WPACKET_close(&spkt)) {
	SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);		SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
	goto err;		goto err;
	}		}
	@@ -853,21 +853,21 @@ int tls_construct_client_hello(SSL *s)
	SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);		SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, SSL_R_CLIENTHELLO_TLSEXT);
	goto err;		goto err;
	}		}
	if (!PACKETW_get_sub_packet_len(&body, &spkt, 2)		if (!WPACKET_get_sub_packet_len(&body, &spkt, 2)
	/*		/*
	* If extensions are of zero length then we don't even add the		* If extensions are of zero length then we don't even add the
	* extensions length bytes		* extensions length bytes
	*/		*/
	\|\| !PACKETW_set_flags(&spkt,		\|\| !WPACKET_set_flags(&spkt,
	OPENSSL_PACKETW_FLAGS_ABANDON_ON_ZERO_LENGTH)		OPENSSL_WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
	\|\| !ssl_add_clienthello_tlsext(s, &spkt, &al)		\|\| !ssl_add_clienthello_tlsext(s, &spkt, &al)
	\|\| !PACKETW_close(&spkt)) {		\|\| !WPACKET_close(&spkt)) {
	ssl3_send_alert(s, SSL3_AL_FATAL, al);		ssl3_send_alert(s, SSL3_AL_FATAL, al);
	SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);		SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
	goto err;		goto err;
	}		}

	if (!PACKETW_close(&body) \|\| !ssl_close_construct_packet(s, &pkt)) {		if (!WPACKET_close(&body) \|\| !ssl_close_construct_packet(s, &pkt)) {
	ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);		ssl3_send_alert(s, SSL3_AL_FATAL, SSL_AD_HANDSHAKE_FAILURE);
	SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);		SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
	goto err;		goto err;
	@@ -2917,7 +2917,7 @@ int ssl_do_client_cert_cb(SSL s, X509 px509, EVP_PKEY *ppkey)
	return i;		return i;
	}		}

	int ssl_cipher_list_to_bytes(SSL s, STACK_OF(SSL_CIPHER) sk, PACKETW *pkt)		int ssl_cipher_list_to_bytes(SSL s, STACK_OF(SSL_CIPHER) sk, WPACKET *pkt)
	{		{
	int i;		int i;
	size_t totlen = 0, len, maxlen;		size_t totlen = 0, len, maxlen;