Lines Matching defs:message
233 * so we can start directly with the message */
374 /* Forward declarations for functions related to message buffering. */
1613 * the debug message and the invocation of
1693 * - If it is, the message contains the IV-prefix,
1789 MBEDTLS_SSL_DEBUG_BUF(4, "message mac", data + rec->data_len,
1797 MBEDTLS_SSL_DEBUG_MSG(1, ("message mac does not match"));
2065 MBEDTLS_SSL_DEBUG_BUF(4, "message mac", mac_peer, transform->maclen);
2071 MBEDTLS_SSL_DEBUG_MSG(1, ("message mac does not match"));
2131 * Fill the input message buffer by appending data to it.
2367 MBEDTLS_SSL_DEBUG_MSG(2, ("message length: %" MBEDTLS_PRINTF_SIZET
2411 * Append current handshake message to current outgoing flight
2418 MBEDTLS_SSL_DEBUG_BUF(4, "message appended to flight",
2421 /* Allocate space for current message */
2435 /* Copy current handshake message with headers */
2527 * Need to remember the current message in case flush_output returns
2564 MBEDTLS_SSL_DEBUG_MSG(2, ("swap epochs to send finished message"));
2591 /* Update position inside current message */
2620 MBEDTLS_SSL_DEBUG_MSG(2, ("fragmenting handshake message (%u > %u)",
2640 /* Copy the handshake message content and set records fields */
2645 /* Update position inside current message */
2649 /* If done with the current message move to the next one if any */
2660 /* Actually send the message out */
2685 * To be called when the last message of an incoming flight is received.
2700 /* Clear future message buffering structure. */
2715 * To be called when the last message of an outgoing flight is send.
2754 * Write (DTLS: or queue) current handshake (including CCS) message.
2758 * - DTLS: save message for resending
2765 * - ssl->out_msglen: 4 + actual handshake message len
2768 * - ssl->out_msg + 4: the handshake message body
2783 MBEDTLS_SSL_DEBUG_MSG(2, ("=> write handshake message"));
2814 * This should never fail as the various message
2848 MBEDTLS_SSL_DEBUG_MSG(1, ("DTLS handshake message too large: "
2904 MBEDTLS_SSL_DEBUG_MSG(2, ("<= write handshake message"));
2933 * - ssl->out_msgtype: type of the message (AppData, Handshake, Alert, CCS)
3047 MBEDTLS_SSL_DEBUG_MSG(1, ("outgoing message counter would wrap"));
3224 MBEDTLS_SSL_DEBUG_MSG(1, ("handshake message too short: %" MBEDTLS_PRINTF_SIZET,
3231 MBEDTLS_SSL_DEBUG_MSG(3, ("handshake message: msglen ="
3254 "received future handshake message of sequence number %u (next %u)",
3260 /* Retransmit only on last message from previous flight, to avoid
3265 MBEDTLS_SSL_DEBUG_MSG(2, ("received message from last flight, "
3275 MBEDTLS_SSL_DEBUG_MSG(2, ("dropping out-of-sequence message: "
3283 /* Wait until message completion to increment in_msg_seq */
3290 MBEDTLS_SSL_DEBUG_MSG(2, ("found fragmented DTLS handshake message"));
3317 /* Handshake message is complete, increment counter */
3461 * and if it doesn't, generate a HelloVerifyRequest message.
3872 * message gets duplicated before the corresponding Finished message,
3991 * data as long as it has not received the client Finished message.
4074 MBEDTLS_SSL_DEBUG_MSG(1, ("invalid zero-length message type: %d", ssl->in_msgtype));
4113 MBEDTLS_SSL_DEBUG_MSG(1, ("incoming message counter would wrap"));
4123 * HelloRetryRequest message, it might receive early data as long as it has
4124 * not received the client Finished message.
4131 * data message before 2nd ClientHello when early_data was received in 1st
4143 3, ("EarlyData: Ignore application message before 2nd ClientHello"));
4161 MBEDTLS_SSL_DEBUG_MSG(1, ("bad message length"));
4230 /* Buffer future message */
4257 MBEDTLS_SSL_DEBUG_MSG(2, ("reuse previously read message"));
4300 MBEDTLS_SSL_DEBUG_MSG(2, ("Injecting buffered CCS message"));
4320 MBEDTLS_SSL_DEBUG_MSG(2, ("Future message with sequence number %u %s buffered.",
4329 * next handshake message. */
4332 /* Synthesize a record containing the buffered HS message. */
4336 * a message that doesn't fit into the input buffer. */
4342 MBEDTLS_SSL_DEBUG_MSG(2, ("Next handshake message has been buffered - load"));
4343 MBEDTLS_SSL_DEBUG_BUF(3, "Buffered handshake message (incl. header)",
4354 MBEDTLS_SSL_DEBUG_MSG(2, ("Next handshake message %u not or only partially bufffered",
4386 * message. Remove buffers used for future messages to gain space,
4392 "Free buffering slot %d to make space for reassembly of next handshake message",
4422 MBEDTLS_SSL_DEBUG_MSG(2, ("Remember CCS message"));
4435 * message - double-check nonetheless. */
4443 /* Silently ignore -- message too far in the future */
4445 ("Ignore future HS message with sequence number %u, "
4454 MBEDTLS_SSL_DEBUG_MSG(2, ("Buffering HS message with sequence number %u, offset %u ",
4466 /* We copy the message back into the input buffer
4472 /* Ignore message */
4476 /* Check if we have enough space to buffer the message. */
4489 /* If we can't buffer a future message because
4492 ("Buffering of future message of size %"
4503 ("Buffering of future message of size %"
4515 ("Reassembly of next message of size %"
4589 MBEDTLS_SSL_DEBUG_MSG(2, ("message %scomplete",
4612 * Consume last content-layer message and potentially
4617 * Remove last handshake message, move content
4644 * Get next Handshake message in the current record
4651 * size instead. Using the total handshake message
4661 * bounds after handling a DTLS message with an unexpected
4886 /* Setup internal message pointers from record structure. */
5042 MBEDTLS_SSL_DEBUG_MSG(1, ("invalid CCS message, len: %" MBEDTLS_PRINTF_SIZET,
5048 MBEDTLS_SSL_DEBUG_MSG(1, ("invalid CCS message, content: %02x",
5085 to be packed in a single message, but Mbed TLS doesn't
5087 MBEDTLS_SSL_DEBUG_MSG(1, ("invalid alert message, len: %" MBEDTLS_PRINTF_SIZET,
5092 MBEDTLS_SSL_DEBUG_MSG(2, ("got an alert message, type: [%u:%u]",
5099 MBEDTLS_SSL_DEBUG_MSG(1, ("is a fatal alert message (msg %d)",
5106 MBEDTLS_SSL_DEBUG_MSG(2, ("is a close notify message"));
5118 /* Silently ignore: fetch new message */
5156 unsigned char message)
5168 MBEDTLS_SSL_DEBUG_MSG(2, ("=> send alert message"));
5169 MBEDTLS_SSL_DEBUG_MSG(3, ("send alert level=%u message=%u", level, message));
5174 ssl->out_msg[1] = message;
5180 MBEDTLS_SSL_DEBUG_MSG(2, ("<= send alert message"));
5219 MBEDTLS_SSL_DEBUG_MSG(1, ("bad change cipher spec message"));
5396 * a message for further processing.
5417 * Case C: A handshake message is being processed.
5427 * Case D: An application data message is being processed
5435 * In all other cases, the rest of the message can be dropped.
5597 MBEDTLS_SSL_DEBUG_MSG(3, ("received post-handshake message"));
5614 /* This function is called from mbedtls_ssl_read() when a handshake message is
5870 * by the post-handshake message has been completed or not. The cases
5877 * a non-handshake, non-application data message while awaiting
5886 * will re-deliver the message that was held back by the client
5911 MBEDTLS_SSL_DEBUG_MSG(1, ("bad application data message"));
5957 * Early Data handshake message.
5977 * Therefore, it is possible that the input message length is 0 and the
6008 * MBEDTLS_ERR_SSL_WANT_WRITE or the message was only partially
6018 * The user is trying to send a message the first time, so we need to
6325 * 0, No alert message.