Lines Matching defs:ret
219 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
225 ret = (func_call); \
226 if (ret != 0) \
272 return ret;
322 int ret = 0;
330 ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
337 ret = ssl_parse_record_header(ssl, buf, buflen, &rec);
338 if (ret != 0) {
339 MBEDTLS_SSL_DEBUG_RET(3, "ssl_parse_record_header", ret);
344 ret = mbedtls_ssl_decrypt_buf(ssl, ssl->transform_in, &rec);
345 if (ret != 0) {
346 MBEDTLS_SSL_DEBUG_RET(3, "mbedtls_ssl_decrypt_buf", ret);
360 if (ret == MBEDTLS_ERR_SSL_UNEXPECTED_CID ||
361 ret == MBEDTLS_ERR_SSL_EARLY_MESSAGE) {
362 ret = MBEDTLS_ERR_SSL_UNEXPECTED_RECORD;
366 return ret;
425 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
452 ret = ssl_get_remaining_space_in_datagram(ssl);
453 if (ret < 0) {
454 return ret;
456 remaining = (size_t) ret;
458 ret = mbedtls_ssl_get_record_expansion(ssl);
459 if (ret < 0) {
460 return ret;
462 expansion = (size_t) ret;
1042 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
1076 ret = mbedtls_md_hmac_update(&transform->md_ctx_enc, add_data,
1078 if (ret != 0) {
1081 ret = mbedtls_md_hmac_update(&transform->md_ctx_enc, data, rec->data_len);
1082 if (ret != 0) {
1085 ret = mbedtls_md_hmac_finish(&transform->md_ctx_enc, mac);
1086 if (ret != 0) {
1089 ret = mbedtls_md_hmac_reset(&transform->md_ctx_enc);
1090 if (ret != 0) {
1108 ret = PSA_TO_MBEDTLS_ERR(status);
1110 if (ret == 0 && status != PSA_SUCCESS) {
1111 ret = PSA_TO_MBEDTLS_ERR(status);
1114 if (ret != 0) {
1115 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_md_hmac_xxx", ret);
1116 return ret;
1145 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
1206 ret = PSA_TO_MBEDTLS_ERR(status);
1207 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_encrypt_buf", ret);
1208 return ret;
1211 if ((ret = mbedtls_cipher_auth_encrypt_ext(&transform->cipher_ctx_enc,
1218 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_auth_encrypt_ext", ret);
1219 return ret;
1249 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
1296 ret = f_rng(p_rng, transform->iv_enc, transform->ivlen);
1297 if (ret != 0) {
1298 return ret;
1316 ret = PSA_TO_MBEDTLS_ERR(status);
1317 MBEDTLS_SSL_DEBUG_RET(1, "psa_cipher_encrypt_setup", ret);
1318 return ret;
1324 ret = PSA_TO_MBEDTLS_ERR(status);
1325 MBEDTLS_SSL_DEBUG_RET(1, "psa_cipher_set_iv", ret);
1326 return ret;
1335 ret = PSA_TO_MBEDTLS_ERR(status);
1336 MBEDTLS_SSL_DEBUG_RET(1, "psa_cipher_update", ret);
1337 return ret;
1346 ret = PSA_TO_MBEDTLS_ERR(status);
1347 MBEDTLS_SSL_DEBUG_RET(1, "psa_cipher_finish", ret);
1348 return ret;
1354 if ((ret = mbedtls_cipher_crypt(&transform->cipher_ctx_enc,
1359 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_crypt", ret);
1360 return ret;
1420 ret = mbedtls_md_hmac_update(&transform->md_ctx_enc, add_data,
1422 if (ret != 0) {
1425 ret = mbedtls_md_hmac_update(&transform->md_ctx_enc,
1427 if (ret != 0) {
1430 ret = mbedtls_md_hmac_finish(&transform->md_ctx_enc, mac);
1431 if (ret != 0) {
1434 ret = mbedtls_md_hmac_reset(&transform->md_ctx_enc);
1435 if (ret != 0) {
1449 ret = PSA_TO_MBEDTLS_ERR(status);
1451 if (ret == 0 && status != PSA_SUCCESS) {
1452 ret = PSA_TO_MBEDTLS_ERR(status);
1455 if (ret != 0) {
1456 MBEDTLS_SSL_DEBUG_RET(1, "HMAC calculation failed", ret);
1457 return ret;
1487 int ret;
1633 ret = PSA_TO_MBEDTLS_ERR(status);
1634 MBEDTLS_SSL_DEBUG_RET(1, "psa_aead_decrypt", ret);
1635 return ret;
1638 if ((ret = mbedtls_cipher_auth_decrypt_ext
1645 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_auth_decrypt_ext", ret);
1647 if (ret == MBEDTLS_ERR_CIPHER_AUTH_FAILED) {
1651 return ret;
1770 ret = mbedtls_md_hmac_update(&transform->md_ctx_dec, add_data,
1772 if (ret != 0) {
1775 ret = mbedtls_md_hmac_update(&transform->md_ctx_dec,
1777 if (ret != 0) {
1780 ret = mbedtls_md_hmac_finish(&transform->md_ctx_dec, mac_expect);
1781 if (ret != 0) {
1784 ret = mbedtls_md_hmac_reset(&transform->md_ctx_dec);
1785 if (ret != 0) {
1798 ret = MBEDTLS_ERR_SSL_INVALID_MAC;
1806 ret = PSA_TO_MBEDTLS_ERR(status);
1808 if (ret == 0 && status != PSA_SUCCESS) {
1809 ret = PSA_TO_MBEDTLS_ERR(status);
1814 if (ret != 0) {
1815 if (ret != MBEDTLS_ERR_SSL_INVALID_MAC) {
1816 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_hmac_xxx", ret);
1818 return ret;
1856 ret = PSA_TO_MBEDTLS_ERR(status);
1857 MBEDTLS_SSL_DEBUG_RET(1, "psa_cipher_decrypt_setup", ret);
1858 return ret;
1864 ret = PSA_TO_MBEDTLS_ERR(status);
1865 MBEDTLS_SSL_DEBUG_RET(1, "psa_cipher_set_iv", ret);
1866 return ret;
1874 ret = PSA_TO_MBEDTLS_ERR(status);
1875 MBEDTLS_SSL_DEBUG_RET(1, "psa_cipher_update", ret);
1876 return ret;
1884 ret = PSA_TO_MBEDTLS_ERR(status);
1885 MBEDTLS_SSL_DEBUG_RET(1, "psa_cipher_finish", ret);
1886 return ret;
1892 if ((ret = mbedtls_cipher_crypt(&transform->cipher_ctx_dec,
1895 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_cipher_crypt", ret);
1896 return ret;
2041 ret = mbedtls_ct_hmac(transform->psa_mac_dec,
2047 ret = mbedtls_ct_hmac(&transform->md_ctx_dec,
2052 if (ret != 0) {
2053 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ct_hmac", ret);
2080 if (ret != 0) {
2081 return ret;
2102 ret = ssl_parse_inner_plaintext(data, &rec->data_len,
2105 if (ret != 0) {
2113 ret = ssl_parse_inner_plaintext(data, &rec->data_len,
2115 if (ret != 0) {
2147 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2230 ret = MBEDTLS_ERR_SSL_TIMEOUT;
2243 ret = ssl->f_recv_timeout(ssl->p_bio, ssl->in_hdr, len,
2246 ret = ssl->f_recv(ssl->p_bio, ssl->in_hdr, len);
2249 MBEDTLS_SSL_DEBUG_RET(2, "ssl->f_recv(_timeout)", ret);
2251 if (ret == 0) {
2256 if (ret == MBEDTLS_ERR_SSL_TIMEOUT) {
2266 if ((ret = mbedtls_ssl_resend(ssl)) != 0) {
2267 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_resend", ret);
2268 return ret;
2276 if ((ret = mbedtls_ssl_resend_hello_request(ssl)) != 0) {
2278 ret);
2279 return ret;
2287 if (ret < 0) {
2288 return ret;
2291 ssl->in_left = ret;
2303 ret = MBEDTLS_ERR_SSL_TIMEOUT;
2306 ret = ssl->f_recv_timeout(ssl->p_bio,
2310 ret = ssl->f_recv(ssl->p_bio,
2318 MBEDTLS_SSL_DEBUG_RET(2, "ssl->f_recv(_timeout)", ret);
2320 if (ret == 0) {
2324 if (ret < 0) {
2325 return ret;
2328 if ((size_t) ret > len) {
2332 ret, len));
2336 ssl->in_left += ret;
2350 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2372 ret = ssl->f_send(ssl->p_bio, buf, ssl->out_left);
2374 MBEDTLS_SSL_DEBUG_RET(2, "ssl->f_send", ret);
2376 if (ret <= 0) {
2377 return ret;
2380 if ((size_t) ret > ssl->out_left) {
2384 ret, ssl->out_left));
2388 ssl->out_left -= ret;
2513 int ret = 0;
2517 ret = mbedtls_ssl_flight_transmit(ssl);
2521 return ret;
2533 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2541 ret = ssl_swap_epochs(ssl);
2542 if (ret != 0) {
2543 return ret;
2565 ret = ssl_swap_epochs(ssl);
2566 if (ret != 0) {
2567 return ret;
2571 ret = ssl_get_remaining_payload_in_datagram(ssl);
2572 if (ret < 0) {
2573 return ret;
2575 max_frag_len = (size_t) ret;
2580 if ((ret = mbedtls_ssl_flush_output(ssl)) != 0) {
2581 return ret;
2602 ret = ssl_swap_epochs(ssl);
2603 if (ret != 0) {
2604 return ret;
2608 if ((ret = mbedtls_ssl_flush_output(ssl)) != 0) {
2609 return ret;
2661 if ((ret = mbedtls_ssl_write_record(ssl, force_flush)) != 0) {
2662 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_record", ret);
2663 return ret;
2667 if ((ret = mbedtls_ssl_flush_output(ssl)) != 0) {
2668 return ret;
2779 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2877 ret = ssl->handshake->update_checksum(ssl, ssl->out_msg,
2879 if (ret != 0) {
2880 MBEDTLS_SSL_DEBUG_RET(1, "update_checksum", ret);
2881 return ret;
2891 if ((ret = ssl_flight_append(ssl)) != 0) {
2892 MBEDTLS_SSL_DEBUG_RET(1, "ssl_flight_append", ret);
2893 return ret;
2898 if ((ret = mbedtls_ssl_write_record(ssl, force_flush)) != 0) {
2899 MBEDTLS_SSL_DEBUG_RET(1, "ssl_write_record", ret);
2900 return ret;
2912 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
2922 return ret;
2939 int ret, done = 0;
2986 if ((ret = mbedtls_ssl_encrypt_buf(ssl, ssl->transform_out, &rec,
2988 MBEDTLS_SSL_DEBUG_RET(1, "ssl_encrypt_buf", ret);
2989 return ret;
3012 ret = ssl_get_remaining_space_in_datagram(ssl);
3013 if (ret < 0) {
3014 return ret;
3017 if (protected_record_size > (size_t) ret) {
3056 ret = ssl_get_remaining_payload_in_datagram(ssl);
3057 if (ret < 0) {
3059 ret);
3060 return ret;
3063 remaining = (size_t) ret;
3075 (ret = mbedtls_ssl_flush_output(ssl)) != 0) {
3076 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_flush_output", ret);
3077 return ret;
3238 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
3270 if ((ret = mbedtls_ssl_resend(ssl)) != 0) {
3271 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_resend", ret);
3272 return ret;
3306 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
3310 ret = ssl->handshake->update_checksum(ssl, ssl->in_msg, ssl->in_hslen);
3311 if (ret != 0) {
3312 MBEDTLS_SSL_DEBUG_RET(1, "update_checksum", ret);
3313 return ret;
3378 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
3387 ret = mbedtls_ssl_dtls_replay_check((mbedtls_ssl_context const *) ssl);
3392 return ret;
3629 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
3641 ret = mbedtls_ssl_check_dtls_clihlo_cookie(
3647 MBEDTLS_SSL_DEBUG_RET(2, "mbedtls_ssl_check_dtls_clihlo_cookie", ret);
3649 if (ret == MBEDTLS_ERR_SSL_HELLO_VERIFY_REQUIRED) {
3664 if (ret == 0) {
3666 if ((ret = mbedtls_ssl_session_reset_int(ssl, 1)) != 0) {
3667 MBEDTLS_SSL_DEBUG_RET(1, "reset", ret);
3668 return ret;
3674 return ret;
3962 int ret, done = 0;
3984 if ((ret = mbedtls_ssl_decrypt_buf(ssl, ssl->transform_in,
3986 MBEDTLS_SSL_DEBUG_RET(1, "ssl_decrypt_buf", ret);
4009 ret = mbedtls_ssl_tls13_check_early_data_len(ssl, rec->data_len);
4010 if (ret != 0) {
4011 return ret;
4013 ret = MBEDTLS_ERR_SSL_CONTINUE_PROCESSING;
4018 if (ret == MBEDTLS_ERR_SSL_UNEXPECTED_CID &&
4022 ret = MBEDTLS_ERR_SSL_CONTINUE_PROCESSING;
4030 return ret;
4137 ret = mbedtls_ssl_tls13_check_early_data_len(ssl, rec->data_len);
4138 if (ret != 0) {
4139 return ret;
4187 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
4194 ret = ssl_consume_current_message(ssl);
4195 if (ret != 0) {
4196 return ret;
4214 ret = ssl_get_next_record(ssl);
4215 if (ret == MBEDTLS_ERR_SSL_CONTINUE_PROCESSING) {
4219 if (ret != 0) {
4220 MBEDTLS_SSL_DEBUG_RET(1, ("ssl_get_next_record"), ret);
4221 return ret;
4226 ret = mbedtls_ssl_handle_message_type(ssl);
4229 if (ret == MBEDTLS_ERR_SSL_EARLY_MESSAGE) {
4231 ret = ssl_buffer_message(ssl);
4232 if (ret != 0) {
4233 return ret;
4236 ret = MBEDTLS_ERR_SSL_CONTINUE_PROCESSING;
4240 } while (MBEDTLS_ERR_SSL_NON_FATAL == ret ||
4241 MBEDTLS_ERR_SSL_CONTINUE_PROCESSING == ret);
4243 if (0 != ret) {
4244 MBEDTLS_SSL_DEBUG_RET(1, ("mbedtls_ssl_handle_message_type"), ret);
4245 return ret;
4250 ret = mbedtls_ssl_update_handshake_status(ssl);
4251 if (0 != ret) {
4252 MBEDTLS_SSL_DEBUG_RET(1, ("mbedtls_ssl_update_handshake_status"), ret);
4253 return ret;
4282 int ret = 0;
4296 ret = -1;
4351 ret = 0;
4358 ret = -1;
4363 return ret;
4411 int ret = 0;
4527 ret = MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL;
4539 ret = MBEDTLS_ERR_SSL_ALLOC_FAILED;
4604 return ret;
4840 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
4850 ret = ssl_load_buffered_record(ssl);
4851 if (ret != 0) {
4852 return ret;
4859 ret = mbedtls_ssl_fetch_input(ssl, mbedtls_ssl_in_hdr_len(ssl));
4860 if (ret != 0) {
4861 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_fetch_input", ret);
4862 return ret;
4865 ret = ssl_parse_record_header(ssl, ssl->in_hdr, ssl->in_left, &rec);
4866 if (ret != 0) {
4869 if (ret == MBEDTLS_ERR_SSL_EARLY_MESSAGE) {
4870 ret = ssl_buffer_future_record(ssl, &rec);
4871 if (ret != 0) {
4872 return ret;
4876 ret = MBEDTLS_ERR_SSL_UNEXPECTED_RECORD;
4879 if (ret == MBEDTLS_ERR_SSL_UNEXPECTED_RECORD) {
4894 ret = ssl_check_client_reconnect(ssl);
4895 MBEDTLS_SSL_DEBUG_RET(2, "ssl_check_client_reconnect", ret);
4896 if (ret != 0) {
4897 return ret;
4920 return ret;
4937 ret = mbedtls_ssl_fetch_input(ssl, rec.buf_len);
4938 if (ret != 0) {
4939 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_fetch_input", ret);
4940 return ret;
4950 if ((ret = ssl_prepare_record_content(ssl, &rec)) != 0) {
4954 if (ret == MBEDTLS_ERR_SSL_INVALID_MAC) {
4961 if (ret == MBEDTLS_ERR_SSL_INVALID_MAC) {
4967 return ret;
4986 return ret;
4992 if (ret == MBEDTLS_ERR_SSL_INVALID_MAC) {
4998 return ret;
5029 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
5035 if ((ret = mbedtls_ssl_prepare_handshake_record(ssl)) != 0) {
5036 return ret;
5158 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
5176 if ((ret = mbedtls_ssl_write_record(ssl, SSL_FORCE_FLUSH)) != 0) {
5177 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_record", ret);
5178 return ret;
5187 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
5197 if ((ret = mbedtls_ssl_write_handshake_msg(ssl)) != 0) {
5198 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_handshake_msg", ret);
5199 return ret;
5209 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
5213 if ((ret = mbedtls_ssl_read_record(ssl, 1)) != 0) {
5214 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_read_record", ret);
5215 return ret;
5601 int ret = ssl_tls13_check_new_session_ticket(ssl);
5602 if (ret != 0) {
5603 return ret;
5626 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
5682 ret = mbedtls_ssl_start_renegotiation(ssl);
5683 if (ret != MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO &&
5684 ret != 0) {
5686 ret);
5687 return ret;
5698 if ((ret = mbedtls_ssl_send_alert_message(ssl,
5701 return ret;
5776 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
5786 if ((ret = mbedtls_ssl_flush_output(ssl)) != 0) {
5787 return ret;
5792 if ((ret = mbedtls_ssl_flight_transmit(ssl)) != 0) {
5793 return ret;
5812 ret = ssl_check_ctr_renegotiate(ssl);
5813 if (ret != MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO &&
5814 ret != 0) {
5815 MBEDTLS_SSL_DEBUG_RET(1, "ssl_check_ctr_renegotiate", ret);
5816 return ret;
5821 ret = mbedtls_ssl_handshake(ssl);
5822 if (ret != MBEDTLS_ERR_SSL_WAITING_SERVER_HELLO_RENEGO &&
5823 ret != 0) {
5824 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_handshake", ret);
5825 return ret;
5837 if ((ret = mbedtls_ssl_read_record(ssl, 1)) != 0) {
5838 if (ret == MBEDTLS_ERR_SSL_CONN_EOF) {
5842 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_read_record", ret);
5843 return ret;
5851 if ((ret = mbedtls_ssl_read_record(ssl, 1)) != 0) {
5852 if (ret == MBEDTLS_ERR_SSL_CONN_EOF) {
5856 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_read_record", ret);
5857 return ret;
5862 ret = ssl_handle_hs_message_post_handshake(ssl);
5863 if (ret != 0) {
5865 ret);
5866 return ret;
5930 if ((ret = mbedtls_ssl_resend_hello_request(ssl)) != 0) {
5932 ret);
5933 return ret;
5940 ret = ssl_read_application_data(ssl, buf, len);
5944 return ret;
5984 int ret = mbedtls_ssl_get_max_out_record_payload(ssl);
5985 const size_t max_len = (size_t) ret;
5987 if (ret < 0) {
5988 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_get_max_out_record_payload", ret);
5989 return ret;
6012 if ((ret = mbedtls_ssl_flush_output(ssl)) != 0) {
6013 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_flush_output", ret);
6014 return ret;
6028 if ((ret = mbedtls_ssl_write_record(ssl, SSL_FORCE_FLUSH)) != 0) {
6029 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_write_record", ret);
6030 return ret;
6042 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
6051 if ((ret = ssl_check_ctr_renegotiate(ssl)) != 0) {
6052 MBEDTLS_SSL_DEBUG_RET(1, "ssl_check_ctr_renegotiate", ret);
6053 return ret;
6058 if ((ret = mbedtls_ssl_handshake(ssl)) != 0) {
6059 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_handshake", ret);
6060 return ret;
6064 ret = ssl_write_real(ssl, buf, len);
6068 return ret;
6075 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
6115 ret = mbedtls_ssl_handshake_step(ssl);
6116 if (ret != 0) {
6117 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_handshake_step", ret);
6118 return ret;
6121 ret = mbedtls_ssl_flush_output(ssl);
6122 if (ret != 0) {
6123 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_flush_output", ret);
6124 return ret;
6148 ret = mbedtls_ssl_handshake(ssl);
6149 if ((ret != 0) && (ret != MBEDTLS_ERR_SSL_WANT_READ)) {
6150 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_handshake", ret);
6151 return ret;
6165 ret = ssl_write_real(ssl, buf, len);
6166 if (ret >= 0) {
6167 ssl->total_early_data_size += ret;
6170 MBEDTLS_SSL_DEBUG_MSG(2, ("<= write early_data, ret=%d", ret));
6172 return ret;
6181 int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
6190 if ((ret = mbedtls_ssl_send_alert_message(ssl,
6193 MBEDTLS_SSL_DEBUG_RET(1, "mbedtls_ssl_send_alert_message", ret);
6194 return ret;
6331 int ret;
6338 ret = mbedtls_ssl_send_alert_message(ssl,
6345 if (ret != MBEDTLS_ERR_SSL_WANT_WRITE) {
6349 if (ret != 0) {
6350 return ret;