From 0fce958f17db2d450d23ea49dcb938c75a187f32 Mon Sep 17 00:00:00 2001 From: Ronald Cron Date: Wed, 13 Mar 2024 14:22:19 +0100 Subject: [PATCH] tls13-early-data.md: Adapt code examples to new coding style Signed-off-by: Ronald Cron --- docs/tls13-early-data.md | 112 +++++++++++++++++++++------------------ 1 file changed, 59 insertions(+), 53 deletions(-) diff --git a/docs/tls13-early-data.md b/docs/tls13-early-data.md index be0574355602..28a8cc6c1862 100644 --- a/docs/tls13-early-data.md +++ b/docs/tls13-early-data.md @@ -6,29 +6,28 @@ An application function to write and send a buffer of data to a server through TLS may plausibly look like: ``` -int write_data( mbedtls_ssl_context *ssl, - const unsigned char *data_to_write, - size_t data_to_write_len, - size_t *data_written ) +int write_data(mbedtls_ssl_context *ssl, + const unsigned char *data_to_write, + size_t data_to_write_len, + size_t *data_written) { + int ret; *data_written = 0; - while( *data_written < data_to_write_len ) - { - ret = mbedtls_ssl_write( ssl, data_to_write + *data_written, - data_to_write_len - *data_written ); + while (*data_written < data_to_write_len) { + ret = mbedtls_ssl_write(ssl, data_to_write + *data_written, + data_to_write_len - *data_written); - if( ret < 0 && + if (ret < 0 && ret != MBEDTLS_ERR_SSL_WANT_READ && - ret != MBEDTLS_ERR_SSL_WANT_WRITE ) - { - return( ret ); + ret != MBEDTLS_ERR_SSL_WANT_WRITE) { + return ret; } *data_written += ret; } - return( 0 ); + return 0; } ``` where ssl is the SSL context to use, data_to_write the address of the data @@ -36,7 +35,7 @@ buffer and data_to_write_len the number of data bytes. The handshake may not be completed, not even started for the SSL context ssl when the function is called and in that case the mbedtls_ssl_write() API takes care transparently of completing the handshake before to write and send data to the server. The -mbedtls_ssl_write() may not been able to write and send all data in one go thus +mbedtls_ssl_write() may not be able to write and send all data in one go thus the need for a loop calling it as long as there are still data to write and send. @@ -45,29 +44,28 @@ data sent during the first flight of client messages while the handshake is in its initial phase, would look completely similar but the call to mbedtls_ssl_write_early_data() instead of mbedtls_ssl_write(). ``` -int write_early_data( mbedtls_ssl_context *ssl, - const unsigned char *data_to_write, - size_t data_to_write_len, - size_t *data_written ) +int write_early_data(mbedtls_ssl_context *ssl, + const unsigned char *data_to_write, + size_t data_to_write_len, + size_t *data_written) { + int ret; *data_written = 0; - while( *data_written < data_to_write_len ) - { - ret = mbedtls_ssl_write_early_data( ssl, data_to_write + *data_written, - data_to_write_len - *data_written ); + while (*data_written < data_to_write_len) { + ret = mbedtls_ssl_write_early_data(ssl, data_to_write + *data_written, + data_to_write_len - *data_written); - if( ret < 0 && + if (ret < 0 && ret != MBEDTLS_ERR_SSL_WANT_READ && - ret != MBEDTLS_ERR_SSL_WANT_WRITE ) - { - return( ret ); + ret != MBEDTLS_ERR_SSL_WANT_WRITE) { + return ret; } *data_written += ret; } - return( 0 ); + return 0; } ``` Note that compared to write_data(), write_early_data() can also return @@ -81,18 +79,22 @@ early data and then as standard post-handshake application data could plausibly look like: ``` -ret = write_early_data( ssl, data_to_write, data_to_write_len, - &early_data_written ); -if( ret < 0 && - ret != MBEDTLS_ERR_SSL_CANNOT_WRITE_EARLY_DATA ) -{ +ret = write_early_data(ssl, + data_to_write, + data_to_write_len, + &early_data_written); +if (ret < 0 && + ret != MBEDTLS_ERR_SSL_CANNOT_WRITE_EARLY_DATA) { goto error; } -ret = write_data( ssl, data_to_write + early_data_written, - data_to_write_len - early_data_written, &data_written ); -if( ret < 0 ) +ret = write_data(ssl, + data_to_write + early_data_written, + data_to_write_len - early_data_written, + &data_written); +if (ret < 0) { goto error; +} data_written += early_data_written; ``` @@ -100,40 +102,44 @@ data_written += early_data_written; Finally, taking into account that the server may reject early data, application code to write and send a buffer of data could plausibly look like: ``` -ret = write_early_data( ssl, data_to_write, data_to_write_len, - &early_data_written ); -if( ret < 0 && - ret != MBEDTLS_ERR_SSL_CANNOT_WRITE_EARLY_DATA ) -{ +ret = write_early_data(ssl, + data_to_write, + data_to_write_len, + &early_data_written); +if (ret < 0 && + ret != MBEDTLS_ERR_SSL_CANNOT_WRITE_EARLY_DATA) { goto error; } /* - * Make sure the handshake is completed as it is a requisite to + * Make sure the handshake is completed as it is a requisite of * mbedtls_ssl_get_early_data_status(). */ -while( !mbedtls_ssl_is_handshake_over( ssl ) ) -{ - ret = mbedtls_ssl_handshake( ssl ); - if( ret < 0 && +while (!mbedtls_ssl_is_handshake_over(ssl)) { + ret = mbedtls_ssl_handshake(ssl); + if (ret < 0 && ret != MBEDTLS_ERR_SSL_WANT_READ && - ret != MBEDTLS_ERR_SSL_WANT_WRITE ) - { + ret != MBEDTLS_ERR_SSL_WANT_WRITE) { goto error; } } -ret = mbedtls_ssl_get_early_data_status( ssl ); -if( ret < 0 ) +ret = mbedtls_ssl_get_early_data_status(ssl); +if (ret < 0) { goto error; +} -if( ret == MBEDTLS_SSL_EARLY_DATA_STATUS_REJECTED ) +if (ret == MBEDTLS_SSL_EARLY_DATA_STATUS_REJECTED) { early_data_written = 0; +} -ret = write_data( ssl, data_to_write + early_data_written, - data_to_write_len - early_data_written, &data_written ); -if( ret < 0 ) +ret = write_data(ssl, + data_to_write + early_data_written, + data_to_write_len - early_data_written, + &data_written); +if (ret < 0) { goto error; +} data_written += early_data_written; ```