/src/openssl/ssl/ssl_stat.c

Source (jump to first uncovered line)
/*
 * Copyright 1995-2025 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";
    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";
    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";
    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";
    default:
        return "unknown";
    }
}

Coverage Report

Created: 2025-07-11 06:57

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 1995-2025 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	default:
128	0	return "unknown state";
129	0	}
130	0	}
131
132		const char SSL_state_string(const SSL s)
133	0	{
134	0	const SSL_CONNECTION *sc = SSL_CONNECTION_FROM_CONST_SSL(s);
135
136	0	if (sc == NULL \|\| ossl_statem_in_error(sc))
137	0	return "SSLERR";
138
139	0	switch (SSL_get_state(s)) {
140	0	case TLS_ST_SR_NEXT_PROTO:
141	0	return "TRNP";
142	0	case TLS_ST_SW_SESSION_TICKET:
143	0	return "TWST";
144	0	case TLS_ST_SW_CERT_STATUS:
145	0	return "TWCS";
146	0	case TLS_ST_CR_CERT_STATUS:
147	0	return "TRCS";
148	0	case TLS_ST_CR_SESSION_TICKET:
149	0	return "TRST";
150	0	case TLS_ST_CW_NEXT_PROTO:
151	0	return "TWNP";
152	0	case TLS_ST_BEFORE:
153	0	return "PINIT";
154	0	case TLS_ST_OK:
155	0	return "SSLOK";
156	0	case TLS_ST_CW_CLNT_HELLO:
157	0	return "TWCH";
158	0	case TLS_ST_CR_SRVR_HELLO:
159	0	return "TRSH";
160	0	case TLS_ST_CR_CERT:
161	0	return "TRSC";
162	0	case TLS_ST_CR_COMP_CERT:
163	0	return "TRSCC";
164	0	case TLS_ST_CR_KEY_EXCH:
165	0	return "TRSKE";
166	0	case TLS_ST_CR_CERT_REQ:
167	0	return "TRCR";
168	0	case TLS_ST_CR_SRVR_DONE:
169	0	return "TRSD";
170	0	case TLS_ST_CW_CERT:
171	0	return "TWCC";
172	0	case TLS_ST_CW_COMP_CERT:
173	0	return "TWCCC";
174	0	case TLS_ST_CW_KEY_EXCH:
175	0	return "TWCKE";
176	0	case TLS_ST_CW_CERT_VRFY:
177	0	return "TWCV";
178	0	case TLS_ST_SW_CHANGE:
179	0	case TLS_ST_CW_CHANGE:
180	0	return "TWCCS";
181	0	case TLS_ST_SW_FINISHED:
182	0	case TLS_ST_CW_FINISHED:
183	0	return "TWFIN";
184	0	case TLS_ST_SR_CHANGE:
185	0	case TLS_ST_CR_CHANGE:
186	0	return "TRCCS";
187	0	case TLS_ST_SR_FINISHED:
188	0	case TLS_ST_CR_FINISHED:
189	0	return "TRFIN";
190	0	case TLS_ST_SW_HELLO_REQ:
191	0	return "TWHR";
192	0	case TLS_ST_SR_CLNT_HELLO:
193	0	return "TRCH";
194	0	case TLS_ST_SW_SRVR_HELLO:
195	0	return "TWSH";
196	0	case TLS_ST_SW_CERT:
197	0	return "TWSC";
198	0	case TLS_ST_SW_COMP_CERT:
199	0	return "TWSCC";
200	0	case TLS_ST_SW_KEY_EXCH:
201	0	return "TWSKE";
202	0	case TLS_ST_SW_CERT_REQ:
203	0	return "TWCR";
204	0	case TLS_ST_SW_SRVR_DONE:
205	0	return "TWSD";
206	0	case TLS_ST_SR_CERT:
207	0	return "TRCC";
208	0	case TLS_ST_SR_COMP_CERT:
209	0	return "TRCCC";
210	0	case TLS_ST_SR_KEY_EXCH:
211	0	return "TRCKE";
212	0	case TLS_ST_SR_CERT_VRFY:
213	0	return "TRCV";
214	0	case DTLS_ST_CR_HELLO_VERIFY_REQUEST:
215	0	return "DRCHV";
216	0	case DTLS_ST_SW_HELLO_VERIFY_REQUEST:
217	0	return "DWCHV";
218	0	case TLS_ST_SW_ENCRYPTED_EXTENSIONS:
219	0	return "TWEE";
220	0	case TLS_ST_CR_ENCRYPTED_EXTENSIONS:
221	0	return "TREE";
222	0	case TLS_ST_CR_CERT_VRFY:
223	0	return "TRSCV";
224	0	case TLS_ST_SW_CERT_VRFY:
225	0	return "TWSCV";
226	0	case TLS_ST_CR_HELLO_REQ:
227	0	return "TRHR";
228	0	case TLS_ST_SW_KEY_UPDATE:
229	0	return "TWSKU";
230	0	case TLS_ST_CW_KEY_UPDATE:
231	0	return "TWCKU";
232	0	case TLS_ST_SR_KEY_UPDATE:
233	0	return "TRCKU";
234	0	case TLS_ST_CR_KEY_UPDATE:
235	0	return "TRSKU";
236	0	case TLS_ST_EARLY_DATA:
237	0	return "TED";
238	0	case TLS_ST_PENDING_EARLY_DATA_END:
239	0	return "TPEDE";
240	0	case TLS_ST_CW_END_OF_EARLY_DATA:
241	0	return "TWEOED";
242	0	case TLS_ST_SR_END_OF_EARLY_DATA:
243	0	return "TWEOED";
244	0	default:
245	0	return "UNKWN";
246	0	}
247	0	}
248
249		const char *SSL_alert_type_string_long(int value)
250	0	{
251	0	switch (value >> 8) {
252	0	case SSL3_AL_WARNING:
253	0	return "warning";
254	0	case SSL3_AL_FATAL:
255	0	return "fatal";
256	0	default:
257	0	return "unknown";
258	0	}
259	0	}
260
261		const char *SSL_alert_type_string(int value)
262	0	{
263	0	switch (value >> 8) {
264	0	case SSL3_AL_WARNING:
265	0	return "W";
266	0	case SSL3_AL_FATAL:
267	0	return "F";
268	0	default:
269	0	return "U";
270	0	}
271	0	}
272
273		const char *SSL_alert_desc_string(int value)
274	0	{
275	0	switch (value & 0xff) {
276	0	case SSL3_AD_CLOSE_NOTIFY:
277	0	return "CN";
278	0	case SSL3_AD_UNEXPECTED_MESSAGE:
279	0	return "UM";
280	0	case SSL3_AD_BAD_RECORD_MAC:
281	0	return "BM";
282	0	case SSL3_AD_DECOMPRESSION_FAILURE:
283	0	return "DF";
284	0	case SSL3_AD_HANDSHAKE_FAILURE:
285	0	return "HF";
286	0	case SSL3_AD_NO_CERTIFICATE:
287	0	return "NC";
288	0	case SSL3_AD_BAD_CERTIFICATE:
289	0	return "BC";
290	0	case SSL3_AD_UNSUPPORTED_CERTIFICATE:
291	0	return "UC";
292	0	case SSL3_AD_CERTIFICATE_REVOKED:
293	0	return "CR";
294	0	case SSL3_AD_CERTIFICATE_EXPIRED:
295	0	return "CE";
296	0	case SSL3_AD_CERTIFICATE_UNKNOWN:
297	0	return "CU";
298	0	case SSL3_AD_ILLEGAL_PARAMETER:
299	0	return "IP";
300	0	case TLS1_AD_DECRYPTION_FAILED:
301	0	return "DC";
302	0	case TLS1_AD_RECORD_OVERFLOW:
303	0	return "RO";
304	0	case TLS1_AD_UNKNOWN_CA:
305	0	return "CA";
306	0	case TLS1_AD_ACCESS_DENIED:
307	0	return "AD";
308	0	case TLS1_AD_DECODE_ERROR:
309	0	return "DE";
310	0	case TLS1_AD_DECRYPT_ERROR:
311	0	return "CY";
312	0	case TLS1_AD_EXPORT_RESTRICTION:
313	0	return "ER";
314	0	case TLS1_AD_PROTOCOL_VERSION:
315	0	return "PV";
316	0	case TLS1_AD_INSUFFICIENT_SECURITY:
317	0	return "IS";
318	0	case TLS1_AD_INTERNAL_ERROR:
319	0	return "IE";
320	0	case TLS1_AD_USER_CANCELLED:
321	0	return "US";
322	0	case TLS1_AD_NO_RENEGOTIATION:
323	0	return "NR";
324	0	case TLS1_AD_UNSUPPORTED_EXTENSION:
325	0	return "UE";
326	0	case TLS1_AD_CERTIFICATE_UNOBTAINABLE:
327	0	return "CO";
328	0	case TLS1_AD_UNRECOGNIZED_NAME:
329	0	return "UN";
330	0	case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
331	0	return "BR";
332	0	case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE:
333	0	return "BH";
334	0	case TLS1_AD_UNKNOWN_PSK_IDENTITY:
335	0	return "UP";
336	0	default:
337	0	return "UK";
338	0	}
339	0	}
340
341		const char *SSL_alert_desc_string_long(int value)
342	0	{
343	0	switch (value & 0xff) {
344	0	case SSL3_AD_CLOSE_NOTIFY:
345	0	return "close notify";
346	0	case SSL3_AD_UNEXPECTED_MESSAGE:
347	0	return "unexpected message";
348	0	case SSL3_AD_BAD_RECORD_MAC:
349	0	return "bad record mac";
350	0	case SSL3_AD_DECOMPRESSION_FAILURE:
351	0	return "decompression failure";
352	0	case SSL3_AD_HANDSHAKE_FAILURE:
353	0	return "handshake failure";
354	0	case SSL3_AD_NO_CERTIFICATE:
355	0	return "no certificate";
356	0	case SSL3_AD_BAD_CERTIFICATE:
357	0	return "bad certificate";
358	0	case SSL3_AD_UNSUPPORTED_CERTIFICATE:
359	0	return "unsupported certificate";
360	0	case SSL3_AD_CERTIFICATE_REVOKED:
361	0	return "certificate revoked";
362	0	case SSL3_AD_CERTIFICATE_EXPIRED:
363	0	return "certificate expired";
364	0	case SSL3_AD_CERTIFICATE_UNKNOWN:
365	0	return "certificate unknown";
366	0	case SSL3_AD_ILLEGAL_PARAMETER:
367	0	return "illegal parameter";
368	0	case TLS1_AD_DECRYPTION_FAILED:
369	0	return "decryption failed";
370	0	case TLS1_AD_RECORD_OVERFLOW:
371	0	return "record overflow";
372	0	case TLS1_AD_UNKNOWN_CA:
373	0	return "unknown CA";
374	0	case TLS1_AD_ACCESS_DENIED:
375	0	return "access denied";
376	0	case TLS1_AD_DECODE_ERROR:
377	0	return "decode error";
378	0	case TLS1_AD_DECRYPT_ERROR:
379	0	return "decrypt error";
380	0	case TLS1_AD_EXPORT_RESTRICTION:
381	0	return "export restriction";
382	0	case TLS1_AD_PROTOCOL_VERSION:
383	0	return "protocol version";
384	0	case TLS1_AD_INSUFFICIENT_SECURITY:
385	0	return "insufficient security";
386	0	case TLS1_AD_INTERNAL_ERROR:
387	0	return "internal error";
388	0	case TLS1_AD_USER_CANCELLED:
389	0	return "user canceled";
390	0	case TLS1_AD_NO_RENEGOTIATION:
391	0	return "no renegotiation";
392	0	case TLS1_AD_UNSUPPORTED_EXTENSION:
393	0	return "unsupported extension";
394	0	case TLS1_AD_CERTIFICATE_UNOBTAINABLE:
395	0	return "certificate unobtainable";
396	0	case TLS1_AD_UNRECOGNIZED_NAME:
397	0	return "unrecognized name";
398	0	case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
399	0	return "bad certificate status response";
400	0	case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE:
401	0	return "bad certificate hash value";
402	0	case TLS1_AD_UNKNOWN_PSK_IDENTITY:
403	0	return "unknown PSK identity";
404	0	case TLS1_AD_NO_APPLICATION_PROTOCOL:
405	0	return "no application protocol";
406	0	default:
407	0	return "unknown";
408	0	}
409	0	}