static const char *quic_err_to_qlog(uint64_t error_code)
{
switch (error_code) {
- case QUIC_ERR_INTERNAL_ERROR:
+ case OSSL_QUIC_ERR_INTERNAL_ERROR:
return "internal_error";
- case QUIC_ERR_CONNECTION_REFUSED:
+ case OSSL_QUIC_ERR_CONNECTION_REFUSED:
return "connection_refused";
- case QUIC_ERR_FLOW_CONTROL_ERROR:
+ case OSSL_QUIC_ERR_FLOW_CONTROL_ERROR:
return "flow_control_error";
- case QUIC_ERR_STREAM_LIMIT_ERROR:
+ case OSSL_QUIC_ERR_STREAM_LIMIT_ERROR:
return "stream_limit_error";
- case QUIC_ERR_STREAM_STATE_ERROR:
+ case OSSL_QUIC_ERR_STREAM_STATE_ERROR:
return "stream_state_error";
- case QUIC_ERR_FINAL_SIZE_ERROR:
+ case OSSL_QUIC_ERR_FINAL_SIZE_ERROR:
return "final_size_error";
- case QUIC_ERR_FRAME_ENCODING_ERROR:
+ case OSSL_QUIC_ERR_FRAME_ENCODING_ERROR:
return "frame_encoding_error";
- case QUIC_ERR_TRANSPORT_PARAMETER_ERROR:
+ case OSSL_QUIC_ERR_TRANSPORT_PARAMETER_ERROR:
return "transport_parameter_error";
- case QUIC_ERR_CONNECTION_ID_LIMIT_ERROR:
+ case OSSL_QUIC_ERR_CONNECTION_ID_LIMIT_ERROR:
return "connection_id_limit_error";
- case QUIC_ERR_PROTOCOL_VIOLATION:
+ case OSSL_QUIC_ERR_PROTOCOL_VIOLATION:
return "protocol_violation";
- case QUIC_ERR_INVALID_TOKEN:
+ case OSSL_QUIC_ERR_INVALID_TOKEN:
return "invalid_token";
- case QUIC_ERR_APPLICATION_ERROR:
+ case OSSL_QUIC_ERR_APPLICATION_ERROR:
return "application_error";
- case QUIC_ERR_CRYPTO_BUFFER_EXCEEDED:
+ case OSSL_QUIC_ERR_CRYPTO_BUFFER_EXCEEDED:
return "crypto_buffer_exceeded";
- case QUIC_ERR_KEY_UPDATE_ERROR:
+ case OSSL_QUIC_ERR_KEY_UPDATE_ERROR:
return "key_update_error";
- case QUIC_ERR_AEAD_LIMIT_REACHED:
+ case OSSL_QUIC_ERR_AEAD_LIMIT_REACHED:
return "aead_limit_reached";
- case QUIC_ERR_NO_VIABLE_PATH:
+ case OSSL_QUIC_ERR_NO_VIABLE_PATH:
return "no_viable_path";
default:
return NULL;
const char *m = quic_err_to_qlog(tcause->error_code);
char ce[32];
- if (tcause->error_code >= QUIC_ERR_CRYPTO_ERR_BEGIN
- && tcause->error_code <= QUIC_ERR_CRYPTO_ERR_END) {
+ if (tcause->error_code >= OSSL_QUIC_ERR_CRYPTO_ERR_BEGIN
+ && tcause->error_code <= OSSL_QUIC_ERR_CRYPTO_ERR_END) {
BIO_snprintf(ce, sizeof(ce), "crypto_error_0x%03llx",
(unsigned long long)tcause->error_code);
m = ce;
if (!ossl_quic_pn_valid(next_pn)
|| !ossl_qtx_trigger_key_update(ch->qtx)) {
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR, 0,
"key update");
return;
}
decision = DECISION_SOLICITED_TXKU;
if (decision == DECISION_PROTOCOL_VIOLATION) {
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_KEY_UPDATE_ERROR,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_KEY_UPDATE_ERROR,
0, "RX key update again too soon");
return;
}
ch->rxku_in_progress = 0;
if (!ossl_qrx_key_update_timeout(ch->qrx, /*normal=*/1))
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR, 0,
"RXKU cooldown internal error");
}
if (i != QUIC_ENC_LEVEL_0RTT &&
!crypto_ensure_empty(ch->crypto_recv[ossl_quic_enc_level_to_pn_space(i)])) {
/* Protocol violation (RFC 9001 s. 4.1.3) */
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
OSSL_QUIC_FRAME_TYPE_CRYPTO,
"crypto stream data in wrong EL");
return 0;
for (i = QUIC_ENC_LEVEL_INITIAL; i < enc_level; ++i)
if (!crypto_ensure_empty(ch->crypto_recv[ossl_quic_enc_level_to_pn_space(i)])) {
/* Protocol violation (RFC 9001 s. 4.1.3) */
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
OSSL_QUIC_FRAME_TYPE_CRYPTO,
"crypto stream data in wrong EL");
return 0;
* Was not a valid QUIC handshake if we did not get valid transport
* params.
*/
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_CRYPTO_MISSING_EXT,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_CRYPTO_MISSING_EXT,
OSSL_QUIC_FRAME_TYPE_CRYPTO,
"no transport parameters received");
return 0;
&& ch->handshake_complete
&& ossl_quic_tls_is_cert_request(ch->qtls))
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
0,
"Post-handshake TLS "
"CertificateRequest received");
&& ch->handshake_complete
&& ossl_quic_tls_has_bad_max_early_data(ch->qtls))
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
0,
"Bad max_early_data received");
else
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_CRYPTO_ERR_BEGIN
+ OSSL_QUIC_ERR_CRYPTO_ERR_BEGIN
+ alert_code,
0, "handshake alert");
}
if (!PACKET_buf_init(&pkt, params, params_len)) {
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR, 0,
"internal error (packet buf init)");
return 0;
}
/* If we are a server, we now generate our own transport parameters. */
if (ch->is_server && !ch_generate_transport_params(ch)) {
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR, 0,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR, 0,
"internal error");
return 0;
}
return 1;
malformed:
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_TRANSPORT_PARAMETER_ERROR,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_TRANSPORT_PARAMETER_ERROR,
0, reason);
return 0;
}
if (ossl_qrx_get_cur_forged_pkt_count(ch->qrx) < limit)
return;
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_AEAD_LIMIT_REACHED, 0,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_AEAD_LIMIT_REACHED, 0,
"forgery limit");
}
*/
if (ossl_quic_pkt_type_is_encrypted(ch->qrx_pkt->hdr->type)
&& ch->qrx_pkt->hdr->reserved != 0) {
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
0, "packet header reserved bits");
return;
}
if (!ch_retry(ch, ch->qrx_pkt->hdr->data,
ch->qrx_pkt->hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN,
&ch->qrx_pkt->hdr->src_conn_id))
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR,
0, "handling retry packet");
break;
* were used for packets with lower packet numbers MUST treat this
* as a connection error of type KEY_UPDATE_ERROR.
*/
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_KEY_UPDATE_ERROR,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_KEY_UPDATE_ERROR,
0, "new packet with old keys");
break;
}
* packets that lack authentication.
* I.e. should we drop this packet instead of closing the connection?
*/
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
0, "client received initial token");
break;
}
{
QUIC_TERMINATE_CAUSE tcause = {0};
- tcause.error_code = QUIC_ERR_CONNECTION_REFUSED;
+ tcause.error_code = OSSL_QUIC_ERR_CONNECTION_REFUSED;
tcause.reason = "version negotiation failure";
tcause.reason_len = strlen(tcause.reason);
* to schedule a CONNECTION_CLOSE frame will not actually cause a
* packet to be transmitted for this reason.
*/
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR,
0,
"internal error (txp generate)");
break;
* This may fail if the token we receive is too big for us to ever be
* able to transmit in an outgoing Initial packet.
*/
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INVALID_TOKEN, 0,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INVALID_TOKEN, 0,
"received oversize token");
OPENSSL_free(buf);
return 0;
* Does not make sense for handshake to be confirmed before it is
* completed.
*/
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_PROTOCOL_VIOLATION,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE,
"handshake cannot be confirmed "
"before it is completed");
err:
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_INTERNAL_ERROR,
+ OSSL_QUIC_ERR_INTERNAL_ERROR,
OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
"internal error enqueueing retire conn id");
BUF_MEM_free(buf_mem);
if (ch->cur_remote_dcid.id_len == 0) {
/* Changing from 0 length connection id is disallowed */
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
"zero length connection id in use");
*/
if (new_remote_seq_num - new_retire_prior_to > 1) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_CONNECTION_ID_LIMIT_ERROR,
+ OSSL_QUIC_ERR_CONNECTION_ID_LIMIT_ERROR,
OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
"active_connection_id limit violated");
return;
*/
if (new_retire_prior_to - ch->cur_retire_prior_to > 10) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_CONNECTION_ID_LIMIT_ERROR,
+ OSSL_QUIC_ERR_CONNECTION_ID_LIMIT_ERROR,
OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
"retiring connection id limit violated");
if (!ossl_quic_srtm_add(ch->srtm, ch, new_remote_seq_num,
&f->stateless_reset)) {
ossl_quic_channel_raise_protocol_error(
- ch, QUIC_ERR_CONNECTION_ID_LIMIT_ERROR,
+ ch, OSSL_QUIC_ERR_CONNECTION_ID_LIMIT_ERROR,
OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
"unable to store stateless reset token");
{
QUIC_TERMINATE_CAUSE tcause = {0};
- tcause.error_code = QUIC_ERR_NO_ERROR;
+ tcause.error_code = OSSL_QUIC_ERR_NO_ERROR;
tcause.remote = 1;
ch_start_terminating(ch, &tcause, 0);
}
ch->net_error = 1;
- tcause.error_code = QUIC_ERR_INTERNAL_ERROR;
+ tcause.error_code = OSSL_QUIC_ERR_INTERNAL_ERROR;
tcause.reason = "network BIO I/O error";
tcause.reason_len = strlen(tcause.reason);
const char *src_func)
{
QUIC_TERMINATE_CAUSE tcause = {0};
- int err_reason = error_code == QUIC_ERR_INTERNAL_ERROR
+ int err_reason = error_code == OSSL_QUIC_ERR_INTERNAL_ERROR
? ERR_R_INTERNAL_ERROR : SSL_R_QUIC_PROTOCOL_ERROR;
const char *err_str = ossl_quic_err_to_string(error_code);
const char *err_str_pfx = " (", *err_str_sfx = ")";
if (num_bytes > credit) {
ok = 0;
num_bytes = credit;
- rxfc->error_code = QUIC_ERR_FLOW_CONTROL_ERROR;
+ rxfc->error_code = OSSL_QUIC_ERR_FLOW_CONTROL_ERROR;
}
rxfc->swm += num_bytes;
if (rxfc->is_fin && ((is_fin && rxfc->hwm != end) || end > rxfc->hwm)) {
/* Stream size cannot change after the stream is finished */
- rxfc->error_code = QUIC_ERR_FINAL_SIZE_ERROR;
+ rxfc->error_code = OSSL_QUIC_ERR_FINAL_SIZE_ERROR;
return 1; /* not a caller error */
}
if (rxfc->parent != NULL)
on_rx_controlled_bytes(rxfc->parent, delta); /* result ignored */
} else if (end < rxfc->hwm && is_fin) {
- rxfc->error_code = QUIC_ERR_FINAL_SIZE_ERROR;
+ rxfc->error_code = OSSL_QUIC_ERR_FINAL_SIZE_ERROR;
return 1; /* not a caller error */
}
/*
* To be called when a protocol violation occurs. The connection is torn down
- * with the given error code, which should be a QUIC_ERR_* value. Reason string
- * is optional and copied if provided. frame_type should be 0 if not applicable.
+ * with the given error code, which should be a OSSL_QUIC_ERR_* value. Reason
+ * string is optional and copied if provided. frame_type should be 0 if not
+ * applicable.
*/
void ossl_quic_conn_raise_protocol_error(QUIC_CONNECTION *qc,
uint64_t error_code,
/* We ignore this frame, apart from eliciting an ACK */
if (!ossl_quic_wire_decode_frame_ping(pkt)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_PING,
"decode error");
return 0;
* epoch has not incremented and ch->rxku_expected is still 1.
*/
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_KEY_UPDATE_ERROR,
+ OSSL_QUIC_ERR_KEY_UPDATE_ERROR,
frame_type,
"acked packet which initiated a "
"key update without a "
malformed:
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
frame_type,
"decode error");
return 0;
if (!ossl_quic_wire_decode_frame_reset_stream(pkt, &frame_data)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
"decode error");
return 0;
if (!ossl_quic_stream_has_recv(stream)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_STREAM_STATE_ERROR,
+ OSSL_QUIC_ERR_STREAM_STATE_ERROR,
OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
"RESET_STREAM frame for "
"TX only stream");
if (!ossl_quic_rxfc_on_rx_stream_frame(&stream->rxfc,
frame_data.final_size, /*is_fin=*/1)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_INTERNAL_ERROR,
+ OSSL_QUIC_ERR_INTERNAL_ERROR,
OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
"internal error (flow control)");
return 0;
/* Has a flow control error occurred? */
fce = ossl_quic_rxfc_get_error(&stream->rxfc, 0);
- if (fce != QUIC_ERR_NO_ERROR) {
+ if (fce != OSSL_QUIC_ERR_NO_ERROR) {
ossl_quic_channel_raise_protocol_error(ch,
fce,
OSSL_QUIC_FRAME_TYPE_RESET_STREAM,
if (!ossl_quic_wire_decode_frame_stop_sending(pkt, &frame_data)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_STOP_SENDING,
"decode error");
return 0;
if (!ossl_quic_stream_has_send(stream)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_STREAM_STATE_ERROR,
+ OSSL_QUIC_ERR_STREAM_STATE_ERROR,
OSSL_QUIC_FRAME_TYPE_STOP_SENDING,
"STOP_SENDING frame for "
"RX only stream");
if (!ossl_quic_wire_decode_frame_crypto(pkt, 0, &f)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_CRYPTO,
"decode error");
return 0;
if (!ossl_quic_rxfc_on_rx_stream_frame(rxfc, f.offset + f.len,
/*is_fin=*/0)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_INTERNAL_ERROR,
+ OSSL_QUIC_ERR_INTERNAL_ERROR,
OSSL_QUIC_FRAME_TYPE_CRYPTO,
"internal error (crypto RXFC)");
return 0;
}
- if (ossl_quic_rxfc_get_error(rxfc, 0) != QUIC_ERR_NO_ERROR) {
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_CRYPTO_BUFFER_EXCEEDED,
+ if (ossl_quic_rxfc_get_error(rxfc, 0) != OSSL_QUIC_ERR_NO_ERROR) {
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_CRYPTO_BUFFER_EXCEEDED,
OSSL_QUIC_FRAME_TYPE_CRYPTO,
"exceeded maximum crypto buffer");
return 0;
if (!ossl_quic_rstream_queue_data(rstream, parent_pkt,
f.offset, f.data, f.len, 0)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_INTERNAL_ERROR,
+ OSSL_QUIC_ERR_INTERNAL_ERROR,
OSSL_QUIC_FRAME_TYPE_CRYPTO,
"internal error (rstream queue)");
return 0;
if (!ossl_quic_wire_decode_frame_new_token(pkt, &token, &token_len)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_NEW_TOKEN,
"decode error");
return 0;
* FRAME_ENCODING_ERROR."
*/
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_NEW_TOKEN,
"zero-length NEW_TOKEN");
return 0;
stream_ordinal + 1,
/*is_fin=*/0)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_INTERNAL_ERROR,
+ OSSL_QUIC_ERR_INTERNAL_ERROR,
frame_type,
"internal error (stream count RXFC)");
return 0;
}
- if (ossl_quic_rxfc_get_error(max_streams_fc, 0) != QUIC_ERR_NO_ERROR) {
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_STREAM_LIMIT_ERROR,
+ if (ossl_quic_rxfc_get_error(max_streams_fc, 0) != OSSL_QUIC_ERR_NO_ERROR) {
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_STREAM_LIMIT_ERROR,
frame_type,
"exceeded maximum allowed streams");
return 0;
stream = ossl_quic_channel_new_stream_remote(ch, cur_stream_id);
if (stream == NULL) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_INTERNAL_ERROR,
+ OSSL_QUIC_ERR_INTERNAL_ERROR,
frame_type,
"internal error (stream allocation)");
return 0;
* violation.
*/
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_STREAM_STATE_ERROR,
+ OSSL_QUIC_ERR_STREAM_STATE_ERROR,
frame_type,
"STREAM frame for nonexistent "
"stream");
if (!ossl_quic_wire_decode_frame_stream(pkt, 0, &frame_data)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
frame_type,
"decode error");
return 0;
if (!ossl_quic_stream_has_recv(stream)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_STREAM_STATE_ERROR,
+ OSSL_QUIC_ERR_STREAM_STATE_ERROR,
frame_type,
"STREAM frame for TX only "
"stream");
frame_data.offset + frame_data.len,
frame_data.is_fin)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_INTERNAL_ERROR,
+ OSSL_QUIC_ERR_INTERNAL_ERROR,
frame_type,
"internal error (flow control)");
return 0;
/* Has a flow control error occurred? */
fce = ossl_quic_rxfc_get_error(&stream->rxfc, 0);
- if (fce != QUIC_ERR_NO_ERROR) {
+ if (fce != OSSL_QUIC_ERR_NO_ERROR) {
ossl_quic_channel_raise_protocol_error(ch,
fce,
frame_type,
frame_data.len,
frame_data.is_fin)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_INTERNAL_ERROR,
+ OSSL_QUIC_ERR_INTERNAL_ERROR,
frame_type,
"internal error (rstream queue)");
return 0;
if (stream->recv_state == QUIC_RSTREAM_STATE_SIZE_KNOWN
&& !ossl_quic_rstream_available(stream->rstream, &rs_avail, &rs_fin)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_INTERNAL_ERROR,
+ OSSL_QUIC_ERR_INTERNAL_ERROR,
frame_type,
"internal error (rstream available)");
return 0;
if (!ossl_quic_wire_decode_frame_max_data(pkt, &max_data)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_MAX_DATA,
"decode error");
return 0;
if (!ossl_quic_wire_decode_frame_max_stream_data(pkt, &stream_id,
&max_stream_data)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA,
"decode error");
return 0;
if (!ossl_quic_stream_has_send(stream)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_STREAM_STATE_ERROR,
+ OSSL_QUIC_ERR_STREAM_STATE_ERROR,
OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA,
"MAX_STREAM_DATA for TX only "
"stream");
if (!ossl_quic_wire_decode_frame_max_streams(pkt, &max_streams)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
frame_type,
"decode error");
return 0;
if (max_streams > (((uint64_t)1) << 60)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
frame_type,
"invalid max streams value");
return 0;
break;
default:
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
frame_type,
"decode error");
return 0;
if (!ossl_quic_wire_decode_frame_data_blocked(pkt, &max_data)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED,
"decode error");
return 0;
if (!ossl_quic_wire_decode_frame_stream_data_blocked(pkt, &stream_id,
&max_data)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED,
"decode error");
return 0;
* STREAM_STATE_ERROR."
*/
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_STREAM_STATE_ERROR,
+ OSSL_QUIC_ERR_STREAM_STATE_ERROR,
OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED,
"STREAM_DATA_BLOCKED frame for "
"TX only stream");
if (!ossl_quic_wire_decode_frame_streams_blocked(pkt, &max_data)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
frame_type,
"decode error");
return 0;
* error of type STREAM_LIMIT_ERROR or FRAME_ENCODING_ERROR."
*/
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_STREAM_LIMIT_ERROR,
+ OSSL_QUIC_ERR_STREAM_LIMIT_ERROR,
frame_type,
"invalid stream count limit");
return 0;
if (!ossl_quic_wire_decode_frame_new_conn_id(pkt, &frame_data)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID,
"decode error");
return 0;
if (!ossl_quic_wire_decode_frame_retire_conn_id(pkt, &seq_num)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID,
"decode error");
return 0;
*/
if (!ch->is_server) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID,
"conn has zero-length CID");
return 0;
if (!ossl_quic_wire_decode_frame_path_challenge(pkt, &frame_data)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE,
"decode error");
return 0;
err:
OPENSSL_free(encoded);
- ossl_quic_channel_raise_protocol_error(ch, QUIC_ERR_INTERNAL_ERROR,
+ ossl_quic_channel_raise_protocol_error(ch, OSSL_QUIC_ERR_INTERNAL_ERROR,
OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE,
"internal error");
return 0;
if (!ossl_quic_wire_decode_frame_path_response(pkt, &frame_data)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE,
"decode error");
return 0;
if (!ossl_quic_wire_decode_frame_conn_close(pkt, &frame_data)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
frame_type,
"decode error");
return 0;
if (!ossl_quic_wire_decode_frame_handshake_done(pkt)) {
/* This can fail only with an internal error. */
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_INTERNAL_ERROR,
+ OSSL_QUIC_ERR_INTERNAL_ERROR,
OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE,
"internal error (decode frame handshake done)");
return 0;
* PROTOCOL_VIOLATION.
*/
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
0,
"empty packet payload");
return 0;
if (!ossl_quic_wire_peek_frame_header(pkt, &frame_type, &was_minimal)) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
0,
"malformed frame header");
return 0;
if (!was_minimal) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"non-minimal frame type encoding");
return 0;
/* ACK frames are valid everywhere except in 0RTT packets */
if (pkt_type == QUIC_PKT_TYPE_0RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"ACK not valid in 0-RTT");
return 0;
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"RESET_STREAM not valid in "
"INITIAL/HANDSHAKE");
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"STOP_SENDING not valid in "
"INITIAL/HANDSHAKE");
/* CRYPTO frames are valid everywhere except in 0RTT packets */
if (pkt_type == QUIC_PKT_TYPE_0RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"CRYPTO frame not valid in 0-RTT");
return 0;
/* NEW_TOKEN frames are valid in 1RTT packets */
if (pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"NEW_TOKEN valid only in 1-RTT");
return 0;
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"STREAM valid only in 0/1-RTT");
return 0;
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"MAX_DATA valid only in 0/1-RTT");
return 0;
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"MAX_STREAM_DATA valid only in 0/1-RTT");
return 0;
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"MAX_STREAMS valid only in 0/1-RTT");
return 0;
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"DATA_BLOCKED valid only in 0/1-RTT");
return 0;
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"STREAM_DATA_BLOCKED valid only in 0/1-RTT");
return 0;
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"STREAMS valid only in 0/1-RTT");
return 0;
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"NEW_CONN_ID valid only in 0/1-RTT");
}
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"RETIRE_CONN_ID valid only in 0/1-RTT");
return 0;
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"PATH_CHALLENGE valid only in 0/1-RTT");
return 0;
/* PATH_RESPONSE frames are valid in 1RTT packets */
if (pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"PATH_CHALLENGE valid only in 1-RTT");
return 0;
if (pkt_type != QUIC_PKT_TYPE_0RTT
&& pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"CONN_CLOSE (APP) valid only in 0/1-RTT");
return 0;
/* HANDSHAKE_DONE frames are valid in 1RTT packets */
if (pkt_type != QUIC_PKT_TYPE_1RTT) {
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_PROTOCOL_VIOLATION,
+ OSSL_QUIC_ERR_PROTOCOL_VIOLATION,
frame_type,
"HANDSHAKE_DONE valid only in 1-RTT");
return 0;
default:
/* Unknown frame type */
ossl_quic_channel_raise_protocol_error(ch,
- QUIC_ERR_FRAME_ENCODING_ERROR,
+ OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,
frame_type,
"Unknown frame type received");
return 0;
OPENSSL_FILE, OPENSSL_LINE, OPENSSL_FUNC)
#define RAISE_INTERNAL_ERROR(qtls) \
- RAISE_ERROR((qtls), QUIC_ERR_INTERNAL_ERROR, "internal error")
+ RAISE_ERROR((qtls), OSSL_QUIC_ERR_INTERNAL_ERROR, "internal error")
int ossl_quic_tls_tick(QUIC_TLS *qtls)
{
return RAISE_INTERNAL_ERROR(qtls);
} else {
if (sc->ext.alpn == NULL || sc->ext.alpn_len == 0)
- return RAISE_ERROR(qtls, QUIC_ERR_CRYPTO_NO_APP_PROTO,
+ return RAISE_ERROR(qtls, OSSL_QUIC_ERR_CRYPTO_NO_APP_PROTO,
"ALPN must be configured when using QUIC");
}
if (!SSL_set_min_proto_version(qtls->args.s, TLS1_3_VERSION))
/* Validate that we have ALPN */
SSL_get0_alpn_selected(qtls->args.s, &alpn, &alpnlen);
if (alpn == NULL || alpnlen == 0)
- return RAISE_ERROR(qtls, QUIC_ERR_CRYPTO_NO_APP_PROTO,
+ return RAISE_ERROR(qtls, OSSL_QUIC_ERR_CRYPTO_NO_APP_PROTO,
"no application protocol negotiated");
qtls->complete = 1;
pf = &f;
pf->is_app = 0;
pf->frame_type = 0;
- pf->error_code = QUIC_ERR_APPLICATION_ERROR;
+ pf->error_code = OSSL_QUIC_ERR_APPLICATION_ERROR;
pf->reason = NULL;
pf->reason_len = 0;
}
const char *ossl_quic_err_to_string(uint64_t error_code)
{
switch (error_code) {
-#define X(name) case QUIC_ERR_##name: return #name;
+#define X(name) case OSSL_QUIC_ERR_##name: return #name;
X(NO_ERROR)
X(INTERNAL_ERROR)
X(CONNECTION_REFUSED)
int qtest_check_server_protocol_err(QUIC_TSERVER *qtserv)
{
- return qtest_check_server_transport_err(qtserv, QUIC_ERR_PROTOCOL_VIOLATION);
+ return qtest_check_server_transport_err(qtserv, OSSL_QUIC_ERR_PROTOCOL_VIOLATION);
}
int qtest_check_server_frame_encoding_err(QUIC_TSERVER *qtserv)
{
- return qtest_check_server_transport_err(qtserv, QUIC_ERR_FRAME_ENCODING_ERROR);
+ return qtest_check_server_transport_err(qtserv, OSSL_QUIC_ERR_FRAME_ENCODING_ERROR);
}
void qtest_fault_free(QTEST_FAULT *fault)
RX_OP_STEP_TIME(250 * OSSL_TIME_MS)
RX_OP_RX(0, INIT_WINDOW_SIZE * 5 + 1, 0)
RX_OP_CHECK_SWM(INIT_WINDOW_SIZE * 5)
- RX_OP_CHECK_ERROR(QUIC_ERR_FLOW_CONTROL_ERROR, 0)
- RX_OP_CHECK_ERROR(QUIC_ERR_FLOW_CONTROL_ERROR, 1)
+ RX_OP_CHECK_ERROR(OSSL_QUIC_ERR_FLOW_CONTROL_ERROR, 0)
+ RX_OP_CHECK_ERROR(OSSL_QUIC_ERR_FLOW_CONTROL_ERROR, 1)
RX_OP_CHECK_ERROR(0, 0)
RX_OP_CHECK_CWM(INIT_WINDOW_SIZE * 5)
/*
/* Test exceeding limit at stream level. */
RX_OP_RX(0, INIT_S_WINDOW_SIZE * 2 + 1, 0)
- RX_OP_CHECK_ERROR_STREAM(0, QUIC_ERR_FLOW_CONTROL_ERROR, 0)
- RX_OP_CHECK_ERROR_STREAM(0, QUIC_ERR_FLOW_CONTROL_ERROR, 1)
+ RX_OP_CHECK_ERROR_STREAM(0, OSSL_QUIC_ERR_FLOW_CONTROL_ERROR, 0)
+ RX_OP_CHECK_ERROR_STREAM(0, OSSL_QUIC_ERR_FLOW_CONTROL_ERROR, 1)
RX_OP_CHECK_ERROR_STREAM(0, 0, 0)
RX_OP_CHECK_ERROR_CONN(0, 0) /* doesn't affect conn */
/* Test exceeding limit at connection level. */
RX_OP_RX(0, INIT_WINDOW_SIZE * 2, 0)
- RX_OP_CHECK_ERROR_CONN(QUIC_ERR_FLOW_CONTROL_ERROR, 0)
- RX_OP_CHECK_ERROR_CONN(QUIC_ERR_FLOW_CONTROL_ERROR, 1)
+ RX_OP_CHECK_ERROR_CONN(OSSL_QUIC_ERR_FLOW_CONTROL_ERROR, 0)
+ RX_OP_CHECK_ERROR_CONN(OSSL_QUIC_ERR_FLOW_CONTROL_ERROR, 1)
RX_OP_CHECK_ERROR_CONN(0, 0)
RX_OP_END
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_PROTOCOL_VIOLATION,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_PROTOCOL_VIOLATION,0,0)
OP_END
};
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_LIMIT_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_LIMIT_ERROR,0,0)
OP_END
};
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_LIMIT_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_LIMIT_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (C_UNI_ID(0) + 1, OSSL_QUIC_FRAME_TYPE_RESET_STREAM)
OP_S_WRITE (a, "fruit", 5)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_STATE_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_STATE_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (C_UNI_ID(1) + 1, OSSL_QUIC_FRAME_TYPE_RESET_STREAM)
OP_S_WRITE (a, "fruit", 5)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_STATE_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_STATE_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (S_UNI_ID(0) + 1, OSSL_QUIC_FRAME_TYPE_STOP_SENDING)
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_STATE_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_STATE_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (C_UNI_ID(0) + 1, OSSL_QUIC_FRAME_TYPE_STOP_SENDING)
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_STATE_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_STATE_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (C_UNI_ID(0) + 1, 1)
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_STATE_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_STATE_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (C_BIDI_ID(0) + 1, 2)
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (C_BIDI_ID(0) + 1, 3)
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FLOW_CONTROL_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FLOW_CONTROL_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (S_UNI_ID(0) + 1, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA)
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_STATE_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_STATE_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (C_BIDI_ID(0) + 1, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA)
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_STATE_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_STATE_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (C_UNI_ID(0) + 1, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED)
OP_S_WRITE (b, "orange", 5)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_STATE_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_STATE_ERROR,0,0)
OP_END
};
OP_S_NEW_STREAM_UNI (b, S_UNI_ID(0))
OP_S_WRITE (b, "orange", 5)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_STATE_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_STATE_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (0, 1)
OP_S_WRITE (a, "orange", 5)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (1, (((uint64_t)1) << 62) - 1)
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (1, 0x100000 /* 1 MiB */)
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_CRYPTO_BUFFER_EXCEEDED,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_CRYPTO_BUFFER_EXCEEDED,0,0)
OP_END
};
OP_S_WRITE (a, "Strawberry", 10)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
OP_S_WRITE (a, "Strawberry", 10)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
OP_S_WRITE (a, "Strawberry", 10)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (1, 0)
OP_S_WRITE (a, "Strawberry", 10)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_CRYPTO_BUFFER_EXCEEDED,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_CRYPTO_BUFFER_EXCEEDED,0,0)
OP_END
};
OP_C_SET_ALPN ("ossltest")
OP_C_CONNECT_WAIT_OR_FAIL()
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_CRYPTO_UNEXPECTED_MESSAGE,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_CRYPTO_UNEXPECTED_MESSAGE,0,0)
OP_END
};
OP_SET_INJECT_WORD (0, 2)
OP_S_WRITE (a, "orange", 5)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (0, 3)
OP_S_WRITE (a, "orange", 5)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_PROTOCOL_VIOLATION,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_PROTOCOL_VIOLATION,0,0)
OP_END
};
S_BIDI_ID(OSSL_QUIC_VLINT_MAX / 4))
OP_S_WRITE (a, "fruit", 5)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_LIMIT_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_LIMIT_ERROR,0,0)
OP_END
};
C_BIDI_ID(OSSL_QUIC_VLINT_MAX / 4))
OP_S_WRITE (a, "fruit", 5)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_STATE_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_STATE_ERROR,0,0)
OP_END
};
OP_SET_INJECT_WORD (S_BIDI_ID(5000) + 1, 4)
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_STREAM_LIMIT_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_STREAM_LIMIT_ERROR,0,0)
OP_END
};
OP_S_NEW_TICKET ()
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_PROTOCOL_VIOLATION, 0, 0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_PROTOCOL_VIOLATION, 0, 0)
OP_END
};
OP_S_NEW_TICKET ()
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_CRYPTO_ERR_BEGIN
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_CRYPTO_ERR_BEGIN
+ SSL_AD_UNEXPECTED_MESSAGE, 0, 0)
OP_END
OP_S_NEW_TICKET ()
OP_S_WRITE (a, "orange", 6)
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_PROTOCOL_VIOLATION, 0, 0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_PROTOCOL_VIOLATION, 0, 0)
OP_END
};
OP_C_SET_ALPN ("ossltest")
OP_C_CONNECT_WAIT_OR_FAIL()
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_CONNECTION_REFUSED,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_CONNECTION_REFUSED,0,0)
OP_END
};
OP_C_SET_ALPN ("ossltest")
OP_C_CONNECT_WAIT_OR_FAIL()
- OP_C_EXPECT_CONN_CLOSE_INFO(QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
+ OP_C_EXPECT_CONN_CLOSE_INFO(OSSL_QUIC_ERR_FRAME_ENCODING_ERROR,0,0)
OP_END
};
};
static const struct forbidden_frame_type forbidden_frame_types[] = {
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_VLINT_MAX, QUIC_ERR_FRAME_ENCODING_ERROR },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_VLINT_MAX, QUIC_ERR_FRAME_ENCODING_ERROR },
- { QUIC_PKT_TYPE_1RTT, OSSL_QUIC_VLINT_MAX, QUIC_ERR_FRAME_ENCODING_ERROR },
-
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_STREAM, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_STOP_SENDING, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_MAX_DATA, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE, QUIC_ERR_PROTOCOL_VIOLATION },
-
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_STREAM, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_STOP_SENDING, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_MAX_DATA, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP, QUIC_ERR_PROTOCOL_VIOLATION },
- { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE, QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_VLINT_MAX, OSSL_QUIC_ERR_FRAME_ENCODING_ERROR },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_VLINT_MAX, OSSL_QUIC_ERR_FRAME_ENCODING_ERROR },
+ { QUIC_PKT_TYPE_1RTT, OSSL_QUIC_VLINT_MAX, OSSL_QUIC_ERR_FRAME_ENCODING_ERROR },
+
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_STREAM, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_STOP_SENDING, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_MAX_DATA, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_INITIAL, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_STREAM, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_RESET_STREAM, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_STOP_SENDING, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_NEW_TOKEN, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_MAX_DATA, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_MAX_STREAM_DATA, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_BIDI, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_MAX_STREAMS_UNI, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_DATA_BLOCKED, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_STREAM_DATA_BLOCKED, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_BIDI, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_STREAMS_BLOCKED_UNI, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_NEW_CONN_ID, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_PATH_CHALLENGE, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_PATH_RESPONSE, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_CONN_CLOSE_APP, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_HANDSHAKE, OSSL_QUIC_FRAME_TYPE_HANDSHAKE_DONE, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
/* Client uses a zero-length CID so this is not allowed. */
- { QUIC_PKT_TYPE_1RTT, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, QUIC_ERR_PROTOCOL_VIOLATION },
+ { QUIC_PKT_TYPE_1RTT, OSSL_QUIC_FRAME_TYPE_RETIRE_CONN_ID, OSSL_QUIC_ERR_PROTOCOL_VIOLATION },
};
static ossl_unused int test_dyn_frame_types(int idx)
goto err;
if (!TEST_true((info.flags & SSL_CONN_CLOSE_FLAG_TRANSPORT) != 0)
- || !TEST_uint64_t_eq(info.error_code, QUIC_ERR_TRANSPORT_PARAMETER_ERROR)
+ || !TEST_uint64_t_eq(info.error_code, OSSL_QUIC_ERR_TRANSPORT_PARAMETER_ERROR)
|| !TEST_ptr(strstr(info.reason, ctx.t->expect_fail))) {
TEST_error("expected connection closure information mismatch"
" during TPARAM test: flags=%llu ec=%llu reason='%s'",
if (idx == 0) {
ext = TLSEXT_TYPE_quic_transport_parameters;
- err = QUIC_ERR_CRYPTO_MISSING_EXT;
+ err = OSSL_QUIC_ERR_CRYPTO_MISSING_EXT;
} else {
ext = TLSEXT_TYPE_application_layer_protocol_negotiation;
- err = QUIC_ERR_CRYPTO_NO_APP_PROTO;
+ err = OSSL_QUIC_ERR_CRYPTO_NO_APP_PROTO;
}
if (!TEST_true(qtest_fault_set_hand_enc_ext_listener(fault,
projects / thirdparty / openssl.git / commitdiff
