/src/openssl/ssl/ssl_stat.c

Source (jump to first uncovered line)
/*
 * Copyright 1995-2021 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"

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: 2024-05-21 06:52

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