/src/openssl/ssl/ssl_stat.c

Source
/*
 * Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
 * Copyright 2005 Nokia. All rights reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include <stdio.h>
#include "ssl_local.h"
#include "internal/ssl_unwrap.h"

const char *SSL_state_string_long(const SSL *s)
{
    const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);

    if (sc == NULL || ossl_statem_in_error(sc))
        return "error";

    switch (SSL_get_state(s)) {
    case TLS_ST_CR_CERT_STATUS:
        return "SSLv3/TLS read certificate status";
    case TLS_ST_CW_NEXT_PROTO:
        return "SSLv3/TLS write next proto";
    case TLS_ST_SR_NEXT_PROTO:
        return "SSLv3/TLS read next proto";
    case TLS_ST_SW_CERT_STATUS:
        return "SSLv3/TLS write certificate status";
    case TLS_ST_BEFORE:
        return "before SSL initialization";
    case TLS_ST_OK:
        return "SSL negotiation finished successfully";
    case TLS_ST_CW_CLNT_HELLO:
        return "SSLv3/TLS write client hello";
    case TLS_ST_CR_SRVR_HELLO:
        return "SSLv3/TLS read server hello";
    case TLS_ST_CR_CERT:
        return "SSLv3/TLS read server certificate";
    case TLS_ST_CR_COMP_CERT:
        return "TLSv1.3 read server compressed certificate";
    case TLS_ST_CR_KEY_EXCH:
        return "SSLv3/TLS read server key exchange";
    case TLS_ST_CR_CERT_REQ:
        return "SSLv3/TLS read server certificate request";
    case TLS_ST_CR_SESSION_TICKET:
        return "SSLv3/TLS read server session ticket";
    case TLS_ST_CR_SRVR_DONE:
        return "SSLv3/TLS read server done";
    case TLS_ST_CW_CERT:
        return "SSLv3/TLS write client certificate";
    case TLS_ST_CW_COMP_CERT:
        return "TLSv1.3 write client compressed certificate";
    case TLS_ST_CW_KEY_EXCH:
        return "SSLv3/TLS write client key exchange";
    case TLS_ST_CW_CERT_VRFY:
        return "SSLv3/TLS write certificate verify";
    case TLS_ST_CW_CHANGE:
    case TLS_ST_SW_CHANGE:
        return "SSLv3/TLS write change cipher spec";
    case TLS_ST_CW_FINISHED:
    case TLS_ST_SW_FINISHED:
        return "SSLv3/TLS write finished";
    case TLS_ST_CR_CHANGE:
    case TLS_ST_SR_CHANGE:
        return "SSLv3/TLS read change cipher spec";
    case TLS_ST_CR_FINISHED:
    case TLS_ST_SR_FINISHED:
        return "SSLv3/TLS read finished";
    case TLS_ST_SR_CLNT_HELLO:
        return "SSLv3/TLS read client hello";
    case TLS_ST_SW_HELLO_REQ:
        return "SSLv3/TLS write hello request";
    case TLS_ST_SW_SRVR_HELLO:
        return "SSLv3/TLS write server hello";
    case TLS_ST_SW_CERT:
        return "SSLv3/TLS write certificate";
    case TLS_ST_SW_COMP_CERT:
        return "TLSv1.3 write server compressed certificate";
    case TLS_ST_SW_KEY_EXCH:
        return "SSLv3/TLS write key exchange";
    case TLS_ST_SW_CERT_REQ:
        return "SSLv3/TLS write certificate request";
    case TLS_ST_SW_SESSION_TICKET:
        return "SSLv3/TLS write session ticket";
    case TLS_ST_SW_SRVR_DONE:
        return "SSLv3/TLS write server done";
    case TLS_ST_SR_CERT:
        return "SSLv3/TLS read client certificate";
    case TLS_ST_SR_COMP_CERT:
        return "TLSv1.3 read client compressed certificate";
    case TLS_ST_SR_KEY_EXCH:
        return "SSLv3/TLS read client key exchange";
    case TLS_ST_SR_CERT_VRFY:
        return "SSLv3/TLS read certificate verify";
    case DTLS_ST_CR_HELLO_VERIFY_REQUEST:
        return "DTLS1 read hello verify request";
    case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
        return "DTLS1 write hello verify request";
    case TLS_ST_SW_ENCRYPTED_EXTENSIONS:
        return "TLSv1.3 write encrypted extensions";
    case TLS_ST_CR_ENCRYPTED_EXTENSIONS:
        return "TLSv1.3 read encrypted extensions";
    case TLS_ST_CR_CERT_VRFY:
        return "TLSv1.3 read server certificate verify";
    case TLS_ST_SW_CERT_VRFY:
        return "TLSv1.3 write server certificate verify";
    case TLS_ST_CR_HELLO_REQ:
        return "SSLv3/TLS read hello request";
    case TLS_ST_SW_KEY_UPDATE:
        return "TLSv1.3 write server key update";
    case TLS_ST_CW_KEY_UPDATE:
        return "TLSv1.3 write client key update";
    case TLS_ST_SR_KEY_UPDATE:
        return "TLSv1.3 read client key update";
    case TLS_ST_CR_KEY_UPDATE:
        return "TLSv1.3 read server key update";
    case TLS_ST_EARLY_DATA:
        return "TLSv1.3 early data";
    case TLS_ST_PENDING_EARLY_DATA_END:
        return "TLSv1.3 pending early data end";
    case TLS_ST_CW_END_OF_EARLY_DATA:
        return "TLSv1.3 write end of early data";
    case TLS_ST_SR_END_OF_EARLY_DATA:
        return "TLSv1.3 read end of early data";
    case TLS_ST_CR_ACK:
        return "DTLSv1.3 read client ack";
    case TLS_ST_CW_ACK:
        return "DTLSv1.3 write client ack";
    case TLS_ST_SR_ACK:
        return "DTLSv1.3 read server ack";
    case TLS_ST_SW_ACK:
        return "DTLSv1.3 write server ack";
    default:
        return "unknown state";
    }
}

const char *SSL_state_string(const SSL *s)
{
    const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);

    if (sc == NULL || ossl_statem_in_error(sc))
        return "SSLERR";

    switch (SSL_get_state(s)) {
    case TLS_ST_SR_NEXT_PROTO:
        return "TRNP";
    case TLS_ST_SW_SESSION_TICKET:
        return "TWST";
    case TLS_ST_SW_CERT_STATUS:
        return "TWCS";
    case TLS_ST_CR_CERT_STATUS:
        return "TRCS";
    case TLS_ST_CR_SESSION_TICKET:
        return "TRST";
    case TLS_ST_CW_NEXT_PROTO:
        return "TWNP";
    case TLS_ST_BEFORE:
        return "PINIT";
    case TLS_ST_OK:
        return "SSLOK";
    case TLS_ST_CW_CLNT_HELLO:
        return "TWCH";
    case TLS_ST_CR_SRVR_HELLO:
        return "TRSH";
    case TLS_ST_CR_CERT:
        return "TRSC";
    case TLS_ST_CR_COMP_CERT:
        return "TRSCC";
    case TLS_ST_CR_KEY_EXCH:
        return "TRSKE";
    case TLS_ST_CR_CERT_REQ:
        return "TRCR";
    case TLS_ST_CR_SRVR_DONE:
        return "TRSD";
    case TLS_ST_CW_CERT:
        return "TWCC";
    case TLS_ST_CW_COMP_CERT:
        return "TWCCC";
    case TLS_ST_CW_KEY_EXCH:
        return "TWCKE";
    case TLS_ST_CW_CERT_VRFY:
        return "TWCV";
    case TLS_ST_SW_CHANGE:
    case TLS_ST_CW_CHANGE:
        return "TWCCS";
    case TLS_ST_SW_FINISHED:
    case TLS_ST_CW_FINISHED:
        return "TWFIN";
    case TLS_ST_SR_CHANGE:
    case TLS_ST_CR_CHANGE:
        return "TRCCS";
    case TLS_ST_SR_FINISHED:
    case TLS_ST_CR_FINISHED:
        return "TRFIN";
    case TLS_ST_SW_HELLO_REQ:
        return "TWHR";
    case TLS_ST_SR_CLNT_HELLO:
        return "TRCH";
    case TLS_ST_SW_SRVR_HELLO:
        return "TWSH";
    case TLS_ST_SW_CERT:
        return "TWSC";
    case TLS_ST_SW_COMP_CERT:
        return "TWSCC";
    case TLS_ST_SW_KEY_EXCH:
        return "TWSKE";
    case TLS_ST_SW_CERT_REQ:
        return "TWCR";
    case TLS_ST_SW_SRVR_DONE:
        return "TWSD";
    case TLS_ST_SR_CERT:
        return "TRCC";
    case TLS_ST_SR_COMP_CERT:
        return "TRCCC";
    case TLS_ST_SR_KEY_EXCH:
        return "TRCKE";
    case TLS_ST_SR_CERT_VRFY:
        return "TRCV";
    case DTLS_ST_CR_HELLO_VERIFY_REQUEST:
        return "DRCHV";
    case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
        return "DWCHV";
    case TLS_ST_SW_ENCRYPTED_EXTENSIONS:
        return "TWEE";
    case TLS_ST_CR_ENCRYPTED_EXTENSIONS:
        return "TREE";
    case TLS_ST_CR_CERT_VRFY:
        return "TRSCV";
    case TLS_ST_SW_CERT_VRFY:
        return "TWSCV";
    case TLS_ST_CR_HELLO_REQ:
        return "TRHR";
    case TLS_ST_SW_KEY_UPDATE:
        return "TWSKU";
    case TLS_ST_CW_KEY_UPDATE:
        return "TWCKU";
    case TLS_ST_SR_KEY_UPDATE:
        return "TRCKU";
    case TLS_ST_CR_KEY_UPDATE:
        return "TRSKU";
    case TLS_ST_EARLY_DATA:
        return "TED";
    case TLS_ST_PENDING_EARLY_DATA_END:
        return "TPEDE";
    case TLS_ST_CW_END_OF_EARLY_DATA:
        return "TWEOED";
    case TLS_ST_SR_END_OF_EARLY_DATA:
        return "TWEOED";
    case TLS_ST_CR_ACK:
        return "TRCACK";
    case TLS_ST_CW_ACK:
        return "TWCACK";
    case TLS_ST_SR_ACK:
        return "TRSACK";
    case TLS_ST_SW_ACK:
        return "TWSACK";
    default:
        return "UNKWN";
    }
}

const char *SSL_alert_type_string_long(int value)
{
    switch (value >> 8) {
    case SSL3_AL_WARNING:
        return "warning";
    case SSL3_AL_FATAL:
        return "fatal";
    default:
        return "unknown";
    }
}

const char *SSL_alert_type_string(int value)
{
    switch (value >> 8) {
    case SSL3_AL_WARNING:
        return "W";
    case SSL3_AL_FATAL:
        return "F";
    default:
        return "U";
    }
}

const char *SSL_alert_desc_string(int value)
{
    switch (value & 0xff) {
    case SSL3_AD_CLOSE_NOTIFY:
        return "CN";
    case SSL3_AD_UNEXPECTED_MESSAGE:
        return "UM";
    case SSL3_AD_BAD_RECORD_MAC:
        return "BM";
    case SSL3_AD_DECOMPRESSION_FAILURE:
        return "DF";
    case SSL3_AD_HANDSHAKE_FAILURE:
        return "HF";
    case SSL3_AD_NO_CERTIFICATE:
        return "NC";
    case SSL3_AD_BAD_CERTIFICATE:
        return "BC";
    case SSL3_AD_UNSUPPORTED_CERTIFICATE:
        return "UC";
    case SSL3_AD_CERTIFICATE_REVOKED:
        return "CR";
    case SSL3_AD_CERTIFICATE_EXPIRED:
        return "CE";
    case SSL3_AD_CERTIFICATE_UNKNOWN:
        return "CU";
    case SSL3_AD_ILLEGAL_PARAMETER:
        return "IP";
    case TLS1_AD_DECRYPTION_FAILED:
        return "DC";
    case TLS1_AD_RECORD_OVERFLOW:
        return "RO";
    case TLS1_AD_UNKNOWN_CA:
        return "CA";
    case TLS1_AD_ACCESS_DENIED:
        return "AD";
    case TLS1_AD_DECODE_ERROR:
        return "DE";
    case TLS1_AD_DECRYPT_ERROR:
        return "CY";
    case TLS1_AD_EXPORT_RESTRICTION:
        return "ER";
    case TLS1_AD_PROTOCOL_VERSION:
        return "PV";
    case TLS1_AD_INSUFFICIENT_SECURITY:
        return "IS";
    case TLS1_AD_INTERNAL_ERROR:
        return "IE";
    case TLS1_AD_USER_CANCELLED:
        return "US";
    case TLS1_AD_NO_RENEGOTIATION:
        return "NR";
    case TLS1_AD_UNSUPPORTED_EXTENSION:
        return "UE";
    case TLS1_AD_CERTIFICATE_UNOBTAINABLE:
        return "CO";
    case TLS1_AD_UNRECOGNIZED_NAME:
        return "UN";
    case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
        return "BR";
    case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE:
        return "BH";
    case TLS1_AD_UNKNOWN_PSK_IDENTITY:
        return "UP";
#ifndef OPENSSL_NO_ECH
    case TLS1_AD_ECH_REQUIRED:
        return "RR";
#endif
    default:
        return "UK";
    }
}

const char *SSL_alert_desc_string_long(int value)
{
    switch (value & 0xff) {
    case SSL3_AD_CLOSE_NOTIFY:
        return "close notify";
    case SSL3_AD_UNEXPECTED_MESSAGE:
        return "unexpected message";
    case SSL3_AD_BAD_RECORD_MAC:
        return "bad record mac";
    case SSL3_AD_DECOMPRESSION_FAILURE:
        return "decompression failure";
    case SSL3_AD_HANDSHAKE_FAILURE:
        return "handshake failure";
    case SSL3_AD_NO_CERTIFICATE:
        return "no certificate";
    case SSL3_AD_BAD_CERTIFICATE:
        return "bad certificate";
    case SSL3_AD_UNSUPPORTED_CERTIFICATE:
        return "unsupported certificate";
    case SSL3_AD_CERTIFICATE_REVOKED:
        return "certificate revoked";
    case SSL3_AD_CERTIFICATE_EXPIRED:
        return "certificate expired";
    case SSL3_AD_CERTIFICATE_UNKNOWN:
        return "certificate unknown";
    case SSL3_AD_ILLEGAL_PARAMETER:
        return "illegal parameter";
    case TLS1_AD_DECRYPTION_FAILED:
        return "decryption failed";
    case TLS1_AD_RECORD_OVERFLOW:
        return "record overflow";
    case TLS1_AD_UNKNOWN_CA:
        return "unknown CA";
    case TLS1_AD_ACCESS_DENIED:
        return "access denied";
    case TLS1_AD_DECODE_ERROR:
        return "decode error";
    case TLS1_AD_DECRYPT_ERROR:
        return "decrypt error";
    case TLS1_AD_EXPORT_RESTRICTION:
        return "export restriction";
    case TLS1_AD_PROTOCOL_VERSION:
        return "protocol version";
    case TLS1_AD_INSUFFICIENT_SECURITY:
        return "insufficient security";
    case TLS1_AD_INTERNAL_ERROR:
        return "internal error";
    case TLS1_AD_USER_CANCELLED:
        return "user canceled";
    case TLS1_AD_NO_RENEGOTIATION:
        return "no renegotiation";
    case TLS1_AD_UNSUPPORTED_EXTENSION:
        return "unsupported extension";
    case TLS1_AD_CERTIFICATE_UNOBTAINABLE:
        return "certificate unobtainable";
    case TLS1_AD_UNRECOGNIZED_NAME:
        return "unrecognized name";
    case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
        return "bad certificate status response";
    case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE:
        return "bad certificate hash value";
    case TLS1_AD_UNKNOWN_PSK_IDENTITY:
        return "unknown PSK identity";
    case TLS1_AD_NO_APPLICATION_PROTOCOL:
        return "no application protocol";
#ifndef OPENSSL_NO_ECH
    case TLS1_AD_ECH_REQUIRED:
        return "ECH required";
#endif
    default:
        return "unknown";
    }
}

Coverage Report

Created: 2026-08-31 06:56

Line	Count	Source
1		/*
2		* Copyright 1995-2026 The OpenSSL Project Authors. All Rights Reserved.
3		* Copyright 2005 Nokia. All rights reserved.
4		*
5		* Licensed under the Apache License 2.0 (the "License"). You may not use
6		* this file except in compliance with the License. You can obtain a copy
7		* in the file LICENSE in the source distribution or at
8		* https://www.openssl.org/source/license.html
9		*/
10
11		#include <stdio.h>
12		#include "ssl_local.h"
13		#include "internal/ssl_unwrap.h"
14
15		const char SSL_state_string_long(const SSL s)
16	0	{
17	0	const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
18
19	0	if (sc == NULL \|\| ossl_statem_in_error(sc))
20	0	return "error";
21
22	0	switch (SSL_get_state(s)) {
23	0	case TLS_ST_CR_CERT_STATUS:
24	0	return "SSLv3/TLS read certificate status";
25	0	case TLS_ST_CW_NEXT_PROTO:
26	0	return "SSLv3/TLS write next proto";
27	0	case TLS_ST_SR_NEXT_PROTO:
28	0	return "SSLv3/TLS read next proto";
29	0	case TLS_ST_SW_CERT_STATUS:
30	0	return "SSLv3/TLS write certificate status";
31	0	case TLS_ST_BEFORE:
32	0	return "before SSL initialization";
33	0	case TLS_ST_OK:
34	0	return "SSL negotiation finished successfully";
35	0	case TLS_ST_CW_CLNT_HELLO:
36	0	return "SSLv3/TLS write client hello";
37	0	case TLS_ST_CR_SRVR_HELLO:
38	0	return "SSLv3/TLS read server hello";
39	0	case TLS_ST_CR_CERT:
40	0	return "SSLv3/TLS read server certificate";
41	0	case TLS_ST_CR_COMP_CERT:
42	0	return "TLSv1.3 read server compressed certificate";
43	0	case TLS_ST_CR_KEY_EXCH:
44	0	return "SSLv3/TLS read server key exchange";
45	0	case TLS_ST_CR_CERT_REQ:
46	0	return "SSLv3/TLS read server certificate request";
47	0	case TLS_ST_CR_SESSION_TICKET:
48	0	return "SSLv3/TLS read server session ticket";
49	0	case TLS_ST_CR_SRVR_DONE:
50	0	return "SSLv3/TLS read server done";
51	0	case TLS_ST_CW_CERT:
52	0	return "SSLv3/TLS write client certificate";
53	0	case TLS_ST_CW_COMP_CERT:
54	0	return "TLSv1.3 write client compressed certificate";
55	0	case TLS_ST_CW_KEY_EXCH:
56	0	return "SSLv3/TLS write client key exchange";
57	0	case TLS_ST_CW_CERT_VRFY:
58	0	return "SSLv3/TLS write certificate verify";
59	0	case TLS_ST_CW_CHANGE:
60	0	case TLS_ST_SW_CHANGE:
61	0	return "SSLv3/TLS write change cipher spec";
62	0	case TLS_ST_CW_FINISHED:
63	0	case TLS_ST_SW_FINISHED:
64	0	return "SSLv3/TLS write finished";
65	0	case TLS_ST_CR_CHANGE:
66	0	case TLS_ST_SR_CHANGE:
67	0	return "SSLv3/TLS read change cipher spec";
68	0	case TLS_ST_CR_FINISHED:
69	0	case TLS_ST_SR_FINISHED:
70	0	return "SSLv3/TLS read finished";
71	0	case TLS_ST_SR_CLNT_HELLO:
72	0	return "SSLv3/TLS read client hello";
73	0	case TLS_ST_SW_HELLO_REQ:
74	0	return "SSLv3/TLS write hello request";
75	0	case TLS_ST_SW_SRVR_HELLO:
76	0	return "SSLv3/TLS write server hello";
77	0	case TLS_ST_SW_CERT:
78	0	return "SSLv3/TLS write certificate";
79	0	case TLS_ST_SW_COMP_CERT:
80	0	return "TLSv1.3 write server compressed certificate";
81	0	case TLS_ST_SW_KEY_EXCH:
82	0	return "SSLv3/TLS write key exchange";
83	0	case TLS_ST_SW_CERT_REQ:
84	0	return "SSLv3/TLS write certificate request";
85	0	case TLS_ST_SW_SESSION_TICKET:
86	0	return "SSLv3/TLS write session ticket";
87	0	case TLS_ST_SW_SRVR_DONE:
88	0	return "SSLv3/TLS write server done";
89	0	case TLS_ST_SR_CERT:
90	0	return "SSLv3/TLS read client certificate";
91	0	case TLS_ST_SR_COMP_CERT:
92	0	return "TLSv1.3 read client compressed certificate";
93	0	case TLS_ST_SR_KEY_EXCH:
94	0	return "SSLv3/TLS read client key exchange";
95	0	case TLS_ST_SR_CERT_VRFY:
96	0	return "SSLv3/TLS read certificate verify";
97	0	case DTLS_ST_CR_HELLO_VERIFY_REQUEST:
98	0	return "DTLS1 read hello verify request";
99	0	case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
100	0	return "DTLS1 write hello verify request";
101	0	case TLS_ST_SW_ENCRYPTED_EXTENSIONS:
102	0	return "TLSv1.3 write encrypted extensions";
103	0	case TLS_ST_CR_ENCRYPTED_EXTENSIONS:
104	0	return "TLSv1.3 read encrypted extensions";
105	0	case TLS_ST_CR_CERT_VRFY:
106	0	return "TLSv1.3 read server certificate verify";
107	0	case TLS_ST_SW_CERT_VRFY:
108	0	return "TLSv1.3 write server certificate verify";
109	0	case TLS_ST_CR_HELLO_REQ:
110	0	return "SSLv3/TLS read hello request";
111	0	case TLS_ST_SW_KEY_UPDATE:
112	0	return "TLSv1.3 write server key update";
113	0	case TLS_ST_CW_KEY_UPDATE:
114	0	return "TLSv1.3 write client key update";
115	0	case TLS_ST_SR_KEY_UPDATE:
116	0	return "TLSv1.3 read client key update";
117	0	case TLS_ST_CR_KEY_UPDATE:
118	0	return "TLSv1.3 read server key update";
119	0	case TLS_ST_EARLY_DATA:
120	0	return "TLSv1.3 early data";
121	0	case TLS_ST_PENDING_EARLY_DATA_END:
122	0	return "TLSv1.3 pending early data end";
123	0	case TLS_ST_CW_END_OF_EARLY_DATA:
124	0	return "TLSv1.3 write end of early data";
125	0	case TLS_ST_SR_END_OF_EARLY_DATA:
126	0	return "TLSv1.3 read end of early data";
127	0	case TLS_ST_CR_ACK:
128	0	return "DTLSv1.3 read client ack";
129	0	case TLS_ST_CW_ACK:
130	0	return "DTLSv1.3 write client ack";
131	0	case TLS_ST_SR_ACK:
132	0	return "DTLSv1.3 read server ack";
133	0	case TLS_ST_SW_ACK:
134	0	return "DTLSv1.3 write server ack";
135	0	default:
136	0	return "unknown state";
137	0	}
138	0	}
139
140		const char SSL_state_string(const SSL s)
141	0	{
142	0	const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
143
144	0	if (sc == NULL \|\| ossl_statem_in_error(sc))
145	0	return "SSLERR";
146
147	0	switch (SSL_get_state(s)) {
148	0	case TLS_ST_SR_NEXT_PROTO:
149	0	return "TRNP";
150	0	case TLS_ST_SW_SESSION_TICKET:
151	0	return "TWST";
152	0	case TLS_ST_SW_CERT_STATUS:
153	0	return "TWCS";
154	0	case TLS_ST_CR_CERT_STATUS:
155	0	return "TRCS";
156	0	case TLS_ST_CR_SESSION_TICKET:
157	0	return "TRST";
158	0	case TLS_ST_CW_NEXT_PROTO:
159	0	return "TWNP";
160	0	case TLS_ST_BEFORE:
161	0	return "PINIT";
162	0	case TLS_ST_OK:
163	0	return "SSLOK";
164	0	case TLS_ST_CW_CLNT_HELLO:
165	0	return "TWCH";
166	0	case TLS_ST_CR_SRVR_HELLO:
167	0	return "TRSH";
168	0	case TLS_ST_CR_CERT:
169	0	return "TRSC";
170	0	case TLS_ST_CR_COMP_CERT:
171	0	return "TRSCC";
172	0	case TLS_ST_CR_KEY_EXCH:
173	0	return "TRSKE";
174	0	case TLS_ST_CR_CERT_REQ:
175	0	return "TRCR";
176	0	case TLS_ST_CR_SRVR_DONE:
177	0	return "TRSD";
178	0	case TLS_ST_CW_CERT:
179	0	return "TWCC";
180	0	case TLS_ST_CW_COMP_CERT:
181	0	return "TWCCC";
182	0	case TLS_ST_CW_KEY_EXCH:
183	0	return "TWCKE";
184	0	case TLS_ST_CW_CERT_VRFY:
185	0	return "TWCV";
186	0	case TLS_ST_SW_CHANGE:
187	0	case TLS_ST_CW_CHANGE:
188	0	return "TWCCS";
189	0	case TLS_ST_SW_FINISHED:
190	0	case TLS_ST_CW_FINISHED:
191	0	return "TWFIN";
192	0	case TLS_ST_SR_CHANGE:
193	0	case TLS_ST_CR_CHANGE:
194	0	return "TRCCS";
195	0	case TLS_ST_SR_FINISHED:
196	0	case TLS_ST_CR_FINISHED:
197	0	return "TRFIN";
198	0	case TLS_ST_SW_HELLO_REQ:
199	0	return "TWHR";
200	0	case TLS_ST_SR_CLNT_HELLO:
201	0	return "TRCH";
202	0	case TLS_ST_SW_SRVR_HELLO:
203	0	return "TWSH";
204	0	case TLS_ST_SW_CERT:
205	0	return "TWSC";
206	0	case TLS_ST_SW_COMP_CERT:
207	0	return "TWSCC";
208	0	case TLS_ST_SW_KEY_EXCH:
209	0	return "TWSKE";
210	0	case TLS_ST_SW_CERT_REQ:
211	0	return "TWCR";
212	0	case TLS_ST_SW_SRVR_DONE:
213	0	return "TWSD";
214	0	case TLS_ST_SR_CERT:
215	0	return "TRCC";
216	0	case TLS_ST_SR_COMP_CERT:
217	0	return "TRCCC";
218	0	case TLS_ST_SR_KEY_EXCH:
219	0	return "TRCKE";
220	0	case TLS_ST_SR_CERT_VRFY:
221	0	return "TRCV";
222	0	case DTLS_ST_CR_HELLO_VERIFY_REQUEST:
223	0	return "DRCHV";
224	0	case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
225	0	return "DWCHV";
226	0	case TLS_ST_SW_ENCRYPTED_EXTENSIONS:
227	0	return "TWEE";
228	0	case TLS_ST_CR_ENCRYPTED_EXTENSIONS:
229	0	return "TREE";
230	0	case TLS_ST_CR_CERT_VRFY:
231	0	return "TRSCV";
232	0	case TLS_ST_SW_CERT_VRFY:
233	0	return "TWSCV";
234	0	case TLS_ST_CR_HELLO_REQ:
235	0	return "TRHR";
236	0	case TLS_ST_SW_KEY_UPDATE:
237	0	return "TWSKU";
238	0	case TLS_ST_CW_KEY_UPDATE:
239	0	return "TWCKU";
240	0	case TLS_ST_SR_KEY_UPDATE:
241	0	return "TRCKU";
242	0	case TLS_ST_CR_KEY_UPDATE:
243	0	return "TRSKU";
244	0	case TLS_ST_EARLY_DATA:
245	0	return "TED";
246	0	case TLS_ST_PENDING_EARLY_DATA_END:
247	0	return "TPEDE";
248	0	case TLS_ST_CW_END_OF_EARLY_DATA:
249	0	return "TWEOED";
250	0	case TLS_ST_SR_END_OF_EARLY_DATA:
251	0	return "TWEOED";
252	0	case TLS_ST_CR_ACK:
253	0	return "TRCACK";
254	0	case TLS_ST_CW_ACK:
255	0	return "TWCACK";
256	0	case TLS_ST_SR_ACK:
257	0	return "TRSACK";
258	0	case TLS_ST_SW_ACK:
259	0	return "TWSACK";
260	0	default:
261	0	return "UNKWN";
262	0	}
263	0	}
264
265		const char *SSL_alert_type_string_long(int value)
266	0	{
267	0	switch (value >> 8) {
268	0	case SSL3_AL_WARNING:
269	0	return "warning";
270	0	case SSL3_AL_FATAL:
271	0	return "fatal";
272	0	default:
273	0	return "unknown";
274	0	}
275	0	}
276
277		const char *SSL_alert_type_string(int value)
278	0	{
279	0	switch (value >> 8) {
280	0	case SSL3_AL_WARNING:
281	0	return "W";
282	0	case SSL3_AL_FATAL:
283	0	return "F";
284	0	default:
285	0	return "U";
286	0	}
287	0	}
288
289		const char *SSL_alert_desc_string(int value)
290	0	{
291	0	switch (value & 0xff) {
292	0	case SSL3_AD_CLOSE_NOTIFY:
293	0	return "CN";
294	0	case SSL3_AD_UNEXPECTED_MESSAGE:
295	0	return "UM";
296	0	case SSL3_AD_BAD_RECORD_MAC:
297	0	return "BM";
298	0	case SSL3_AD_DECOMPRESSION_FAILURE:
299	0	return "DF";
300	0	case SSL3_AD_HANDSHAKE_FAILURE:
301	0	return "HF";
302	0	case SSL3_AD_NO_CERTIFICATE:
303	0	return "NC";
304	0	case SSL3_AD_BAD_CERTIFICATE:
305	0	return "BC";
306	0	case SSL3_AD_UNSUPPORTED_CERTIFICATE:
307	0	return "UC";
308	0	case SSL3_AD_CERTIFICATE_REVOKED:
309	0	return "CR";
310	0	case SSL3_AD_CERTIFICATE_EXPIRED:
311	0	return "CE";
312	0	case SSL3_AD_CERTIFICATE_UNKNOWN:
313	0	return "CU";
314	0	case SSL3_AD_ILLEGAL_PARAMETER:
315	0	return "IP";
316	0	case TLS1_AD_DECRYPTION_FAILED:
317	0	return "DC";
318	0	case TLS1_AD_RECORD_OVERFLOW:
319	0	return "RO";
320	0	case TLS1_AD_UNKNOWN_CA:
321	0	return "CA";
322	0	case TLS1_AD_ACCESS_DENIED:
323	0	return "AD";
324	0	case TLS1_AD_DECODE_ERROR:
325	0	return "DE";
326	0	case TLS1_AD_DECRYPT_ERROR:
327	0	return "CY";
328	0	case TLS1_AD_EXPORT_RESTRICTION:
329	0	return "ER";
330	0	case TLS1_AD_PROTOCOL_VERSION:
331	0	return "PV";
332	0	case TLS1_AD_INSUFFICIENT_SECURITY:
333	0	return "IS";
334	0	case TLS1_AD_INTERNAL_ERROR:
335	0	return "IE";
336	0	case TLS1_AD_USER_CANCELLED:
337	0	return "US";
338	0	case TLS1_AD_NO_RENEGOTIATION:
339	0	return "NR";
340	0	case TLS1_AD_UNSUPPORTED_EXTENSION:
341	0	return "UE";
342	0	case TLS1_AD_CERTIFICATE_UNOBTAINABLE:
343	0	return "CO";
344	0	case TLS1_AD_UNRECOGNIZED_NAME:
345	0	return "UN";
346	0	case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
347	0	return "BR";
348	0	case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE:
349	0	return "BH";
350	0	case TLS1_AD_UNKNOWN_PSK_IDENTITY:
351	0	return "UP";
352	0	#ifndef OPENSSL_NO_ECH
353	0	case TLS1_AD_ECH_REQUIRED:
354	0	return "RR";
355	0	#endif
356	0	default:
357	0	return "UK";
358	0	}
359	0	}
360
361		const char *SSL_alert_desc_string_long(int value)
362	0	{
363	0	switch (value & 0xff) {
364	0	case SSL3_AD_CLOSE_NOTIFY:
365	0	return "close notify";
366	0	case SSL3_AD_UNEXPECTED_MESSAGE:
367	0	return "unexpected message";
368	0	case SSL3_AD_BAD_RECORD_MAC:
369	0	return "bad record mac";
370	0	case SSL3_AD_DECOMPRESSION_FAILURE:
371	0	return "decompression failure";
372	0	case SSL3_AD_HANDSHAKE_FAILURE:
373	0	return "handshake failure";
374	0	case SSL3_AD_NO_CERTIFICATE:
375	0	return "no certificate";
376	0	case SSL3_AD_BAD_CERTIFICATE:
377	0	return "bad certificate";
378	0	case SSL3_AD_UNSUPPORTED_CERTIFICATE:
379	0	return "unsupported certificate";
380	0	case SSL3_AD_CERTIFICATE_REVOKED:
381	0	return "certificate revoked";
382	0	case SSL3_AD_CERTIFICATE_EXPIRED:
383	0	return "certificate expired";
384	0	case SSL3_AD_CERTIFICATE_UNKNOWN:
385	0	return "certificate unknown";
386	0	case SSL3_AD_ILLEGAL_PARAMETER:
387	0	return "illegal parameter";
388	0	case TLS1_AD_DECRYPTION_FAILED:
389	0	return "decryption failed";
390	0	case TLS1_AD_RECORD_OVERFLOW:
391	0	return "record overflow";
392	0	case TLS1_AD_UNKNOWN_CA:
393	0	return "unknown CA";
394	0	case TLS1_AD_ACCESS_DENIED:
395	0	return "access denied";
396	0	case TLS1_AD_DECODE_ERROR:
397	0	return "decode error";
398	0	case TLS1_AD_DECRYPT_ERROR:
399	0	return "decrypt error";
400	0	case TLS1_AD_EXPORT_RESTRICTION:
401	0	return "export restriction";
402	0	case TLS1_AD_PROTOCOL_VERSION:
403	0	return "protocol version";
404	0	case TLS1_AD_INSUFFICIENT_SECURITY:
405	0	return "insufficient security";
406	0	case TLS1_AD_INTERNAL_ERROR:
407	0	return "internal error";
408	0	case TLS1_AD_USER_CANCELLED:
409	0	return "user canceled";
410	0	case TLS1_AD_NO_RENEGOTIATION:
411	0	return "no renegotiation";
412	0	case TLS1_AD_UNSUPPORTED_EXTENSION:
413	0	return "unsupported extension";
414	0	case TLS1_AD_CERTIFICATE_UNOBTAINABLE:
415	0	return "certificate unobtainable";
416	0	case TLS1_AD_UNRECOGNIZED_NAME:
417	0	return "unrecognized name";
418	0	case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
419	0	return "bad certificate status response";
420	0	case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE:
421	0	return "bad certificate hash value";
422	0	case TLS1_AD_UNKNOWN_PSK_IDENTITY:
423	0	return "unknown PSK identity";
424	0	case TLS1_AD_NO_APPLICATION_PROTOCOL:
425	0	return "no application protocol";
426	0	#ifndef OPENSSL_NO_ECH
427	0	case TLS1_AD_ECH_REQUIRED:
428	0	return "ECH required";
429	0	#endif
430	0	default:
431	0	return "unknown";
432	0	}
433	0	}