Lines Matching defs:message
234 * so we can start directly with the message */
375 /* Forward declarations for functions related to message buffering. */
1614 * the debug message and the invocation of
1694 * - If it is, the message contains the IV-prefix,
1790 MBEDTLS_SSL_DEBUG_BUF(4, "message mac", data + rec->data_len,
1798 MBEDTLS_SSL_DEBUG_MSG(1, ("message mac does not match"));
2066 MBEDTLS_SSL_DEBUG_BUF(4, "message mac", mac_peer, transform->maclen);
2072 MBEDTLS_SSL_DEBUG_MSG(1, ("message mac does not match"));
2132 * Fill the input message buffer by appending data to it.
2368 MBEDTLS_SSL_DEBUG_MSG(2, ("message length: %" MBEDTLS_PRINTF_SIZET
2412 * Append current handshake message to current outgoing flight
2419 MBEDTLS_SSL_DEBUG_BUF(4, "message appended to flight",
2422 /* Allocate space for current message */
2436 /* Copy current handshake message with headers */
2528 * Need to remember the current message in case flush_output returns
2565 MBEDTLS_SSL_DEBUG_MSG(2, ("swap epochs to send finished message"));
2592 /* Update position inside current message */
2621 MBEDTLS_SSL_DEBUG_MSG(2, ("fragmenting handshake message (%u > %u)",
2641 /* Copy the handshake message content and set records fields */
2646 /* Update position inside current message */
2650 /* If done with the current message move to the next one if any */
2661 /* Actually send the message out */
2686 * To be called when the last message of an incoming flight is received.
2701 /* Clear future message buffering structure. */
2716 * To be called when the last message of an outgoing flight is send.
2755 * Write (DTLS: or queue) current handshake (including CCS) message.
2759 * - DTLS: save message for resending
2766 * - ssl->out_msglen: 4 + actual handshake message len
2769 * - ssl->out_msg + 4: the handshake message body
2784 MBEDTLS_SSL_DEBUG_MSG(2, ("=> write handshake message"));
2815 * This should never fail as the various message
2849 MBEDTLS_SSL_DEBUG_MSG(1, ("DTLS handshake message too large: "
2905 MBEDTLS_SSL_DEBUG_MSG(2, ("<= write handshake message"));
2934 * - ssl->out_msgtype: type of the message (AppData, Handshake, Alert, CCS)
3048 MBEDTLS_SSL_DEBUG_MSG(1, ("outgoing message counter would wrap"));
3225 /* The handshake message must at least include the header.
3226 * We may not have the full message yet in case of fragmentation.
3228 * particular the handshake message length) in the first
3231 MBEDTLS_SSL_DEBUG_MSG(1, ("handshake message too short: %" MBEDTLS_PRINTF_SIZET,
3239 MBEDTLS_SSL_DEBUG_MSG(3, ("handshake message: msglen ="
3245 MBEDTLS_SSL_DEBUG_MSG(4, ("decrypted handshake message:"
3270 "received future handshake message of sequence number %u (next %u)",
3276 /* Retransmit only on last message from previous flight, to avoid
3281 MBEDTLS_SSL_DEBUG_MSG(2, ("received message from last flight, "
3291 MBEDTLS_SSL_DEBUG_MSG(2, ("dropping out-of-sequence message: "
3299 /* Wait until message completion to increment in_msg_seq */
3306 MBEDTLS_SSL_DEBUG_MSG(2, ("found fragmented DTLS handshake message"));
3317 /* How many more bytes we want to have a complete handshake message. */
3320 * handshake message. There may be more handshake messages (possibly
3323 * care of consuming the next handshake message. */
3342 /* Move the received handshake fragment to have the whole message
3426 /* Handshake message is complete, increment counter */
3570 * and if it doesn't, generate a HelloVerifyRequest message.
3982 * message gets duplicated before the corresponding Finished message,
4101 * data as long as it has not received the client Finished message.
4184 MBEDTLS_SSL_DEBUG_MSG(1, ("invalid zero-length message type: %d", ssl->in_msgtype));
4223 MBEDTLS_SSL_DEBUG_MSG(1, ("incoming message counter would wrap"));
4233 * HelloRetryRequest message, it might receive early data as long as it has
4234 * not received the client Finished message.
4241 * data message before 2nd ClientHello when early_data was received in 1st
4253 3, ("EarlyData: Ignore application message before 2nd ClientHello"));
4271 MBEDTLS_SSL_DEBUG_MSG(1, ("bad message length"));
4340 /* Buffer future message */
4367 MBEDTLS_SSL_DEBUG_MSG(2, ("reuse previously read message"));
4410 MBEDTLS_SSL_DEBUG_MSG(2, ("Injecting buffered CCS message"));
4430 MBEDTLS_SSL_DEBUG_MSG(2, ("Future message with sequence number %u %s buffered.",
4439 * next handshake message. */
4442 /* Synthesize a record containing the buffered HS message. */
4446 * a message that doesn't fit into the input buffer. */
4452 MBEDTLS_SSL_DEBUG_MSG(2, ("Next handshake message has been buffered - load"));
4453 MBEDTLS_SSL_DEBUG_BUF(3, "Buffered handshake message (incl. header)",
4464 MBEDTLS_SSL_DEBUG_MSG(2, ("Next handshake message %u not or only partially buffered",
4496 * message. Remove buffers used for future messages to gain space,
4502 "Free buffering slot %d to make space for reassembly of next handshake message",
4532 MBEDTLS_SSL_DEBUG_MSG(2, ("Remember CCS message"));
4545 * message - double-check nonetheless. */
4553 /* Silently ignore -- message too far in the future */
4555 ("Ignore future HS message with sequence number %u, "
4564 MBEDTLS_SSL_DEBUG_MSG(2, ("Buffering HS message with sequence number %u, offset %u ",
4576 /* We copy the message back into the input buffer
4582 /* Ignore message */
4586 /* Check if we have enough space to buffer the message. */
4599 /* If we can't buffer a future message because
4602 ("Buffering of future message of size %"
4613 ("Buffering of future message of size %"
4625 ("Reassembly of next message of size %"
4699 MBEDTLS_SSL_DEBUG_MSG(2, ("message %scomplete",
4722 * Consume last content-layer message and potentially
4727 * Remove last handshake message, move content
4762 * Get next Handshake message in the current record
4769 * size instead. Using the total handshake message
4779 * bounds after handling a DTLS message with an unexpected
5005 /* Setup internal message pointers from record structure. */
5152 /* If we're in the middle of a fragmented TLS handshake message,
5153 * we don't accept any other message type. For TLS 1.3, the spec forbids
5154 * interleaving other message types between handshake fragments. For TLS
5159 MBEDTLS_SSL_DEBUG_MSG(1, ("non-handshake message in the middle"
5160 " of a fragmented handshake message"));
5175 MBEDTLS_SSL_DEBUG_MSG(1, ("invalid CCS message, len: %" MBEDTLS_PRINTF_SIZET,
5181 MBEDTLS_SSL_DEBUG_MSG(1, ("invalid CCS message, content: %02x",
5212 to be packed in a single message, but Mbed TLS doesn't
5214 MBEDTLS_SSL_DEBUG_MSG(1, ("invalid alert message, len: %" MBEDTLS_PRINTF_SIZET,
5219 MBEDTLS_SSL_DEBUG_MSG(2, ("got an alert message, type: [%u:%u]",
5226 MBEDTLS_SSL_DEBUG_MSG(1, ("is a fatal alert message (msg %d)",
5233 MBEDTLS_SSL_DEBUG_MSG(2, ("is a close notify message"));
5245 /* Silently ignore: fetch new message */
5283 unsigned char message)
5295 MBEDTLS_SSL_DEBUG_MSG(2, ("=> send alert message"));
5296 MBEDTLS_SSL_DEBUG_MSG(3, ("send alert level=%u message=%u", level, message));
5301 ssl->out_msg[1] = message;
5307 MBEDTLS_SSL_DEBUG_MSG(2, ("<= send alert message"));
5346 MBEDTLS_SSL_DEBUG_MSG(1, ("bad change cipher spec message"));
5534 * a message for further processing.
5555 * Case C: A handshake message is being processed.
5565 * Case D: An application data message is being processed
5573 * In all other cases, the rest of the message can be dropped.
5729 MBEDTLS_SSL_DEBUG_MSG(3, ("received post-handshake message"));
5761 /* This function is called from mbedtls_ssl_read() when a handshake message is
6017 * by the post-handshake message has been completed or not. The cases
6024 * a non-handshake, non-application data message while awaiting
6033 * will re-deliver the message that was held back by the client
6058 MBEDTLS_SSL_DEBUG_MSG(1, ("bad application data message"));
6104 * Early Data handshake message.
6124 * Therefore, it is possible that the input message length is 0 and the
6155 * MBEDTLS_ERR_SSL_WANT_WRITE or the message was only partially
6165 * The user is trying to send a message the first time, so we need to
6472 * 0, No alert message.