/src/openssl/ssl/ssl_stat.c

Source (jump to first uncovered line)
/*
 * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
 * Copyright 2005 Nokia. All rights reserved.
 *
 * Licensed under the OpenSSL license (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_locl.h"

const char *SSL_state_string_long(const SSL *s)
{
    if (ossl_statem_in_error(s))
        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_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_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_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_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)
{
    if (ossl_statem_in_error(s))
        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_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_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_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_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 "TRSCV";
    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: 2018-08-29 13:53

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