Encapsulate s->s3->wrec
[openssl.git] / ssl / ssl_stat.c
1 /* ssl/ssl_stat.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  *
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  *
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58 /* ====================================================================
59  * Copyright 2005 Nokia. All rights reserved.
60  *
61  * The portions of the attached software ("Contribution") is developed by
62  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
63  * license.
64  *
65  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
66  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
67  * support (see RFC 4279) to OpenSSL.
68  *
69  * No patent licenses or other rights except those expressly stated in
70  * the OpenSSL open source license shall be deemed granted or received
71  * expressly, by implication, estoppel, or otherwise.
72  *
73  * No assurances are provided by Nokia that the Contribution does not
74  * infringe the patent or other intellectual property rights of any third
75  * party or that the license provides you with all the necessary rights
76  * to make use of the Contribution.
77  *
78  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
79  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
80  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
81  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
82  * OTHERWISE.
83  */
84
85 #include <stdio.h>
86 #include "ssl_locl.h"
87
88 const char *SSL_state_string_long(const SSL *s)
89 {
90     const char *str;
91
92     switch (s->state) {
93     case SSL_ST_BEFORE:
94         str = "before SSL initialization";
95         break;
96     case SSL_ST_ACCEPT:
97         str = "before accept initialization";
98         break;
99     case SSL_ST_CONNECT:
100         str = "before connect initialization";
101         break;
102     case SSL_ST_OK:
103         str = "SSL negotiation finished successfully";
104         break;
105     case SSL_ST_RENEGOTIATE:
106         str = "SSL renegotiate ciphers";
107         break;
108     case SSL_ST_BEFORE | SSL_ST_CONNECT:
109         str = "before/connect initialization";
110         break;
111     case SSL_ST_OK | SSL_ST_CONNECT:
112         str = "ok/connect SSL initialization";
113         break;
114     case SSL_ST_BEFORE | SSL_ST_ACCEPT:
115         str = "before/accept initialization";
116         break;
117     case SSL_ST_OK | SSL_ST_ACCEPT:
118         str = "ok/accept SSL initialization";
119         break;
120
121 #ifndef OPENSSL_NO_SSL3
122 /* SSLv3 additions */
123     case SSL3_ST_CW_CLNT_HELLO_A:
124         str = "SSLv3 write client hello A";
125         break;
126     case SSL3_ST_CW_CLNT_HELLO_B:
127         str = "SSLv3 write client hello B";
128         break;
129     case SSL3_ST_CR_SRVR_HELLO_A:
130         str = "SSLv3 read server hello A";
131         break;
132     case SSL3_ST_CR_SRVR_HELLO_B:
133         str = "SSLv3 read server hello B";
134         break;
135     case SSL3_ST_CR_CERT_A:
136         str = "SSLv3 read server certificate A";
137         break;
138     case SSL3_ST_CR_CERT_B:
139         str = "SSLv3 read server certificate B";
140         break;
141     case SSL3_ST_CR_KEY_EXCH_A:
142         str = "SSLv3 read server key exchange A";
143         break;
144     case SSL3_ST_CR_KEY_EXCH_B:
145         str = "SSLv3 read server key exchange B";
146         break;
147     case SSL3_ST_CR_CERT_REQ_A:
148         str = "SSLv3 read server certificate request A";
149         break;
150     case SSL3_ST_CR_CERT_REQ_B:
151         str = "SSLv3 read server certificate request B";
152         break;
153     case SSL3_ST_CR_SESSION_TICKET_A:
154         str = "SSLv3 read server session ticket A";
155         break;
156     case SSL3_ST_CR_SESSION_TICKET_B:
157         str = "SSLv3 read server session ticket B";
158         break;
159     case SSL3_ST_CR_SRVR_DONE_A:
160         str = "SSLv3 read server done A";
161         break;
162     case SSL3_ST_CR_SRVR_DONE_B:
163         str = "SSLv3 read server done B";
164         break;
165     case SSL3_ST_CW_CERT_A:
166         str = "SSLv3 write client certificate A";
167         break;
168     case SSL3_ST_CW_CERT_B:
169         str = "SSLv3 write client certificate B";
170         break;
171     case SSL3_ST_CW_CERT_C:
172         str = "SSLv3 write client certificate C";
173         break;
174     case SSL3_ST_CW_CERT_D:
175         str = "SSLv3 write client certificate D";
176         break;
177     case SSL3_ST_CW_KEY_EXCH_A:
178         str = "SSLv3 write client key exchange A";
179         break;
180     case SSL3_ST_CW_KEY_EXCH_B:
181         str = "SSLv3 write client key exchange B";
182         break;
183     case SSL3_ST_CW_CERT_VRFY_A:
184         str = "SSLv3 write certificate verify A";
185         break;
186     case SSL3_ST_CW_CERT_VRFY_B:
187         str = "SSLv3 write certificate verify B";
188         break;
189
190     case SSL3_ST_CW_CHANGE_A:
191     case SSL3_ST_SW_CHANGE_A:
192         str = "SSLv3 write change cipher spec A";
193         break;
194     case SSL3_ST_CW_CHANGE_B:
195     case SSL3_ST_SW_CHANGE_B:
196         str = "SSLv3 write change cipher spec B";
197         break;
198     case SSL3_ST_CW_FINISHED_A:
199     case SSL3_ST_SW_FINISHED_A:
200         str = "SSLv3 write finished A";
201         break;
202     case SSL3_ST_CW_FINISHED_B:
203     case SSL3_ST_SW_FINISHED_B:
204         str = "SSLv3 write finished B";
205         break;
206     case SSL3_ST_CR_CHANGE_A:
207     case SSL3_ST_SR_CHANGE_A:
208         str = "SSLv3 read change cipher spec A";
209         break;
210     case SSL3_ST_CR_CHANGE_B:
211     case SSL3_ST_SR_CHANGE_B:
212         str = "SSLv3 read change cipher spec B";
213         break;
214     case SSL3_ST_CR_FINISHED_A:
215     case SSL3_ST_SR_FINISHED_A:
216         str = "SSLv3 read finished A";
217         break;
218     case SSL3_ST_CR_FINISHED_B:
219     case SSL3_ST_SR_FINISHED_B:
220         str = "SSLv3 read finished B";
221         break;
222
223     case SSL3_ST_CW_FLUSH:
224     case SSL3_ST_SW_FLUSH:
225         str = "SSLv3 flush data";
226         break;
227
228     case SSL3_ST_SR_CLNT_HELLO_A:
229         str = "SSLv3 read client hello A";
230         break;
231     case SSL3_ST_SR_CLNT_HELLO_B:
232         str = "SSLv3 read client hello B";
233         break;
234     case SSL3_ST_SR_CLNT_HELLO_C:
235         str = "SSLv3 read client hello C";
236         break;
237     case SSL3_ST_SW_HELLO_REQ_A:
238         str = "SSLv3 write hello request A";
239         break;
240     case SSL3_ST_SW_HELLO_REQ_B:
241         str = "SSLv3 write hello request B";
242         break;
243     case SSL3_ST_SW_HELLO_REQ_C:
244         str = "SSLv3 write hello request C";
245         break;
246     case SSL3_ST_SW_SRVR_HELLO_A:
247         str = "SSLv3 write server hello A";
248         break;
249     case SSL3_ST_SW_SRVR_HELLO_B:
250         str = "SSLv3 write server hello B";
251         break;
252     case SSL3_ST_SW_CERT_A:
253         str = "SSLv3 write certificate A";
254         break;
255     case SSL3_ST_SW_CERT_B:
256         str = "SSLv3 write certificate B";
257         break;
258     case SSL3_ST_SW_KEY_EXCH_A:
259         str = "SSLv3 write key exchange A";
260         break;
261     case SSL3_ST_SW_KEY_EXCH_B:
262         str = "SSLv3 write key exchange B";
263         break;
264     case SSL3_ST_SW_CERT_REQ_A:
265         str = "SSLv3 write certificate request A";
266         break;
267     case SSL3_ST_SW_CERT_REQ_B:
268         str = "SSLv3 write certificate request B";
269         break;
270     case SSL3_ST_SW_SESSION_TICKET_A:
271         str = "SSLv3 write session ticket A";
272         break;
273     case SSL3_ST_SW_SESSION_TICKET_B:
274         str = "SSLv3 write session ticket B";
275         break;
276     case SSL3_ST_SW_SRVR_DONE_A:
277         str = "SSLv3 write server done A";
278         break;
279     case SSL3_ST_SW_SRVR_DONE_B:
280         str = "SSLv3 write server done B";
281         break;
282     case SSL3_ST_SR_CERT_A:
283         str = "SSLv3 read client certificate A";
284         break;
285     case SSL3_ST_SR_CERT_B:
286         str = "SSLv3 read client certificate B";
287         break;
288     case SSL3_ST_SR_KEY_EXCH_A:
289         str = "SSLv3 read client key exchange A";
290         break;
291     case SSL3_ST_SR_KEY_EXCH_B:
292         str = "SSLv3 read client key exchange B";
293         break;
294     case SSL3_ST_SR_CERT_VRFY_A:
295         str = "SSLv3 read certificate verify A";
296         break;
297     case SSL3_ST_SR_CERT_VRFY_B:
298         str = "SSLv3 read certificate verify B";
299         break;
300 #endif
301
302 /* SSLv2/v3 compatibility states */
303 /* client */
304     case SSL23_ST_CW_CLNT_HELLO_A:
305         str = "SSLv2/v3 write client hello A";
306         break;
307     case SSL23_ST_CW_CLNT_HELLO_B:
308         str = "SSLv2/v3 write client hello B";
309         break;
310     case SSL23_ST_CR_SRVR_HELLO_A:
311         str = "SSLv2/v3 read server hello A";
312         break;
313     case SSL23_ST_CR_SRVR_HELLO_B:
314         str = "SSLv2/v3 read server hello B";
315         break;
316 /* server */
317     case SSL23_ST_SR_CLNT_HELLO_A:
318         str = "SSLv2/v3 read client hello A";
319         break;
320     case SSL23_ST_SR_CLNT_HELLO_B:
321         str = "SSLv2/v3 read client hello B";
322         break;
323
324 /* DTLS */
325     case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A:
326         str = "DTLS1 read hello verify request A";
327         break;
328     case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B:
329         str = "DTLS1 read hello verify request B";
330         break;
331     case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A:
332         str = "DTLS1 write hello verify request A";
333         break;
334     case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B:
335         str = "DTLS1 write hello verify request B";
336         break;
337
338     default:
339         str = "unknown state";
340         break;
341     }
342     return (str);
343 }
344
345 const char *SSL_rstate_string_long(const SSL *s)
346 {
347     const char *str;
348
349     switch (s->rstate) {
350     case SSL_ST_READ_HEADER:
351         str = "read header";
352         break;
353     case SSL_ST_READ_BODY:
354         str = "read body";
355         break;
356     case SSL_ST_READ_DONE:
357         str = "read done";
358         break;
359     default:
360         str = "unknown";
361         break;
362     }
363     return (str);
364 }
365
366 const char *SSL_state_string(const SSL *s)
367 {
368     const char *str;
369
370     switch (s->state) {
371     case SSL_ST_BEFORE:
372         str = "PINIT ";
373         break;
374     case SSL_ST_ACCEPT:
375         str = "AINIT ";
376         break;
377     case SSL_ST_CONNECT:
378         str = "CINIT ";
379         break;
380     case SSL_ST_OK:
381         str = "SSLOK ";
382         break;
383
384 #ifndef OPENSSL_NO_SSL3
385 /* SSLv3 additions */
386     case SSL3_ST_SW_FLUSH:
387     case SSL3_ST_CW_FLUSH:
388         str = "3FLUSH";
389         break;
390     case SSL3_ST_CW_CLNT_HELLO_A:
391         str = "3WCH_A";
392         break;
393     case SSL3_ST_CW_CLNT_HELLO_B:
394         str = "3WCH_B";
395         break;
396     case SSL3_ST_CR_SRVR_HELLO_A:
397         str = "3RSH_A";
398         break;
399     case SSL3_ST_CR_SRVR_HELLO_B:
400         str = "3RSH_B";
401         break;
402     case SSL3_ST_CR_CERT_A:
403         str = "3RSC_A";
404         break;
405     case SSL3_ST_CR_CERT_B:
406         str = "3RSC_B";
407         break;
408     case SSL3_ST_CR_KEY_EXCH_A:
409         str = "3RSKEA";
410         break;
411     case SSL3_ST_CR_KEY_EXCH_B:
412         str = "3RSKEB";
413         break;
414     case SSL3_ST_CR_CERT_REQ_A:
415         str = "3RCR_A";
416         break;
417     case SSL3_ST_CR_CERT_REQ_B:
418         str = "3RCR_B";
419         break;
420     case SSL3_ST_CR_SRVR_DONE_A:
421         str = "3RSD_A";
422         break;
423     case SSL3_ST_CR_SRVR_DONE_B:
424         str = "3RSD_B";
425         break;
426     case SSL3_ST_CW_CERT_A:
427         str = "3WCC_A";
428         break;
429     case SSL3_ST_CW_CERT_B:
430         str = "3WCC_B";
431         break;
432     case SSL3_ST_CW_CERT_C:
433         str = "3WCC_C";
434         break;
435     case SSL3_ST_CW_CERT_D:
436         str = "3WCC_D";
437         break;
438     case SSL3_ST_CW_KEY_EXCH_A:
439         str = "3WCKEA";
440         break;
441     case SSL3_ST_CW_KEY_EXCH_B:
442         str = "3WCKEB";
443         break;
444     case SSL3_ST_CW_CERT_VRFY_A:
445         str = "3WCV_A";
446         break;
447     case SSL3_ST_CW_CERT_VRFY_B:
448         str = "3WCV_B";
449         break;
450
451     case SSL3_ST_SW_CHANGE_A:
452     case SSL3_ST_CW_CHANGE_A:
453         str = "3WCCSA";
454         break;
455     case SSL3_ST_SW_CHANGE_B:
456     case SSL3_ST_CW_CHANGE_B:
457         str = "3WCCSB";
458         break;
459     case SSL3_ST_SW_FINISHED_A:
460     case SSL3_ST_CW_FINISHED_A:
461         str = "3WFINA";
462         break;
463     case SSL3_ST_SW_FINISHED_B:
464     case SSL3_ST_CW_FINISHED_B:
465         str = "3WFINB";
466         break;
467     case SSL3_ST_SR_CHANGE_A:
468     case SSL3_ST_CR_CHANGE_A:
469         str = "3RCCSA";
470         break;
471     case SSL3_ST_SR_CHANGE_B:
472     case SSL3_ST_CR_CHANGE_B:
473         str = "3RCCSB";
474         break;
475     case SSL3_ST_SR_FINISHED_A:
476     case SSL3_ST_CR_FINISHED_A:
477         str = "3RFINA";
478         break;
479     case SSL3_ST_SR_FINISHED_B:
480     case SSL3_ST_CR_FINISHED_B:
481         str = "3RFINB";
482         break;
483
484     case SSL3_ST_SW_HELLO_REQ_A:
485         str = "3WHR_A";
486         break;
487     case SSL3_ST_SW_HELLO_REQ_B:
488         str = "3WHR_B";
489         break;
490     case SSL3_ST_SW_HELLO_REQ_C:
491         str = "3WHR_C";
492         break;
493     case SSL3_ST_SR_CLNT_HELLO_A:
494         str = "3RCH_A";
495         break;
496     case SSL3_ST_SR_CLNT_HELLO_B:
497         str = "3RCH_B";
498         break;
499     case SSL3_ST_SR_CLNT_HELLO_C:
500         str = "3RCH_C";
501         break;
502     case SSL3_ST_SW_SRVR_HELLO_A:
503         str = "3WSH_A";
504         break;
505     case SSL3_ST_SW_SRVR_HELLO_B:
506         str = "3WSH_B";
507         break;
508     case SSL3_ST_SW_CERT_A:
509         str = "3WSC_A";
510         break;
511     case SSL3_ST_SW_CERT_B:
512         str = "3WSC_B";
513         break;
514     case SSL3_ST_SW_KEY_EXCH_A:
515         str = "3WSKEA";
516         break;
517     case SSL3_ST_SW_KEY_EXCH_B:
518         str = "3WSKEB";
519         break;
520     case SSL3_ST_SW_CERT_REQ_A:
521         str = "3WCR_A";
522         break;
523     case SSL3_ST_SW_CERT_REQ_B:
524         str = "3WCR_B";
525         break;
526     case SSL3_ST_SW_SRVR_DONE_A:
527         str = "3WSD_A";
528         break;
529     case SSL3_ST_SW_SRVR_DONE_B:
530         str = "3WSD_B";
531         break;
532     case SSL3_ST_SR_CERT_A:
533         str = "3RCC_A";
534         break;
535     case SSL3_ST_SR_CERT_B:
536         str = "3RCC_B";
537         break;
538     case SSL3_ST_SR_KEY_EXCH_A:
539         str = "3RCKEA";
540         break;
541     case SSL3_ST_SR_KEY_EXCH_B:
542         str = "3RCKEB";
543         break;
544     case SSL3_ST_SR_CERT_VRFY_A:
545         str = "3RCV_A";
546         break;
547     case SSL3_ST_SR_CERT_VRFY_B:
548         str = "3RCV_B";
549         break;
550 #endif
551
552 /* SSLv2/v3 compatibility states */
553 /* client */
554     case SSL23_ST_CW_CLNT_HELLO_A:
555         str = "23WCHA";
556         break;
557     case SSL23_ST_CW_CLNT_HELLO_B:
558         str = "23WCHB";
559         break;
560     case SSL23_ST_CR_SRVR_HELLO_A:
561         str = "23RSHA";
562         break;
563     case SSL23_ST_CR_SRVR_HELLO_B:
564         str = "23RSHA";
565         break;
566 /* server */
567     case SSL23_ST_SR_CLNT_HELLO_A:
568         str = "23RCHA";
569         break;
570     case SSL23_ST_SR_CLNT_HELLO_B:
571         str = "23RCHB";
572         break;
573
574 /* DTLS */
575     case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A:
576         str = "DRCHVA";
577         break;
578     case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B:
579         str = "DRCHVB";
580         break;
581     case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A:
582         str = "DWCHVA";
583         break;
584     case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B:
585         str = "DWCHVB";
586         break;
587
588     default:
589         str = "UNKWN ";
590         break;
591     }
592     return (str);
593 }
594
595 const char *SSL_alert_type_string_long(int value)
596 {
597     value >>= 8;
598     if (value == SSL3_AL_WARNING)
599         return ("warning");
600     else if (value == SSL3_AL_FATAL)
601         return ("fatal");
602     else
603         return ("unknown");
604 }
605
606 const char *SSL_alert_type_string(int value)
607 {
608     value >>= 8;
609     if (value == SSL3_AL_WARNING)
610         return ("W");
611     else if (value == SSL3_AL_FATAL)
612         return ("F");
613     else
614         return ("U");
615 }
616
617 const char *SSL_alert_desc_string(int value)
618 {
619     const char *str;
620
621     switch (value & 0xff) {
622     case SSL3_AD_CLOSE_NOTIFY:
623         str = "CN";
624         break;
625     case SSL3_AD_UNEXPECTED_MESSAGE:
626         str = "UM";
627         break;
628     case SSL3_AD_BAD_RECORD_MAC:
629         str = "BM";
630         break;
631     case SSL3_AD_DECOMPRESSION_FAILURE:
632         str = "DF";
633         break;
634     case SSL3_AD_HANDSHAKE_FAILURE:
635         str = "HF";
636         break;
637     case SSL3_AD_NO_CERTIFICATE:
638         str = "NC";
639         break;
640     case SSL3_AD_BAD_CERTIFICATE:
641         str = "BC";
642         break;
643     case SSL3_AD_UNSUPPORTED_CERTIFICATE:
644         str = "UC";
645         break;
646     case SSL3_AD_CERTIFICATE_REVOKED:
647         str = "CR";
648         break;
649     case SSL3_AD_CERTIFICATE_EXPIRED:
650         str = "CE";
651         break;
652     case SSL3_AD_CERTIFICATE_UNKNOWN:
653         str = "CU";
654         break;
655     case SSL3_AD_ILLEGAL_PARAMETER:
656         str = "IP";
657         break;
658     case TLS1_AD_DECRYPTION_FAILED:
659         str = "DC";
660         break;
661     case TLS1_AD_RECORD_OVERFLOW:
662         str = "RO";
663         break;
664     case TLS1_AD_UNKNOWN_CA:
665         str = "CA";
666         break;
667     case TLS1_AD_ACCESS_DENIED:
668         str = "AD";
669         break;
670     case TLS1_AD_DECODE_ERROR:
671         str = "DE";
672         break;
673     case TLS1_AD_DECRYPT_ERROR:
674         str = "CY";
675         break;
676     case TLS1_AD_EXPORT_RESTRICTION:
677         str = "ER";
678         break;
679     case TLS1_AD_PROTOCOL_VERSION:
680         str = "PV";
681         break;
682     case TLS1_AD_INSUFFICIENT_SECURITY:
683         str = "IS";
684         break;
685     case TLS1_AD_INTERNAL_ERROR:
686         str = "IE";
687         break;
688     case TLS1_AD_USER_CANCELLED:
689         str = "US";
690         break;
691     case TLS1_AD_NO_RENEGOTIATION:
692         str = "NR";
693         break;
694     case TLS1_AD_UNSUPPORTED_EXTENSION:
695         str = "UE";
696         break;
697     case TLS1_AD_CERTIFICATE_UNOBTAINABLE:
698         str = "CO";
699         break;
700     case TLS1_AD_UNRECOGNIZED_NAME:
701         str = "UN";
702         break;
703     case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
704         str = "BR";
705         break;
706     case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE:
707         str = "BH";
708         break;
709     case TLS1_AD_UNKNOWN_PSK_IDENTITY:
710         str = "UP";
711         break;
712     default:
713         str = "UK";
714         break;
715     }
716     return (str);
717 }
718
719 const char *SSL_alert_desc_string_long(int value)
720 {
721     const char *str;
722
723     switch (value & 0xff) {
724     case SSL3_AD_CLOSE_NOTIFY:
725         str = "close notify";
726         break;
727     case SSL3_AD_UNEXPECTED_MESSAGE:
728         str = "unexpected_message";
729         break;
730     case SSL3_AD_BAD_RECORD_MAC:
731         str = "bad record mac";
732         break;
733     case SSL3_AD_DECOMPRESSION_FAILURE:
734         str = "decompression failure";
735         break;
736     case SSL3_AD_HANDSHAKE_FAILURE:
737         str = "handshake failure";
738         break;
739     case SSL3_AD_NO_CERTIFICATE:
740         str = "no certificate";
741         break;
742     case SSL3_AD_BAD_CERTIFICATE:
743         str = "bad certificate";
744         break;
745     case SSL3_AD_UNSUPPORTED_CERTIFICATE:
746         str = "unsupported certificate";
747         break;
748     case SSL3_AD_CERTIFICATE_REVOKED:
749         str = "certificate revoked";
750         break;
751     case SSL3_AD_CERTIFICATE_EXPIRED:
752         str = "certificate expired";
753         break;
754     case SSL3_AD_CERTIFICATE_UNKNOWN:
755         str = "certificate unknown";
756         break;
757     case SSL3_AD_ILLEGAL_PARAMETER:
758         str = "illegal parameter";
759         break;
760     case TLS1_AD_DECRYPTION_FAILED:
761         str = "decryption failed";
762         break;
763     case TLS1_AD_RECORD_OVERFLOW:
764         str = "record overflow";
765         break;
766     case TLS1_AD_UNKNOWN_CA:
767         str = "unknown CA";
768         break;
769     case TLS1_AD_ACCESS_DENIED:
770         str = "access denied";
771         break;
772     case TLS1_AD_DECODE_ERROR:
773         str = "decode error";
774         break;
775     case TLS1_AD_DECRYPT_ERROR:
776         str = "decrypt error";
777         break;
778     case TLS1_AD_EXPORT_RESTRICTION:
779         str = "export restriction";
780         break;
781     case TLS1_AD_PROTOCOL_VERSION:
782         str = "protocol version";
783         break;
784     case TLS1_AD_INSUFFICIENT_SECURITY:
785         str = "insufficient security";
786         break;
787     case TLS1_AD_INTERNAL_ERROR:
788         str = "internal error";
789         break;
790     case TLS1_AD_USER_CANCELLED:
791         str = "user canceled";
792         break;
793     case TLS1_AD_NO_RENEGOTIATION:
794         str = "no renegotiation";
795         break;
796     case TLS1_AD_UNSUPPORTED_EXTENSION:
797         str = "unsupported extension";
798         break;
799     case TLS1_AD_CERTIFICATE_UNOBTAINABLE:
800         str = "certificate unobtainable";
801         break;
802     case TLS1_AD_UNRECOGNIZED_NAME:
803         str = "unrecognized name";
804         break;
805     case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
806         str = "bad certificate status response";
807         break;
808     case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE:
809         str = "bad certificate hash value";
810         break;
811     case TLS1_AD_UNKNOWN_PSK_IDENTITY:
812         str = "unknown PSK identity";
813         break;
814     default:
815         str = "unknown";
816         break;
817     }
818     return (str);
819 }
820
821 const char *SSL_rstate_string(const SSL *s)
822 {
823     const char *str;
824
825     switch (s->rstate) {
826     case SSL_ST_READ_HEADER:
827         str = "RH";
828         break;
829     case SSL_ST_READ_BODY:
830         str = "RB";
831         break;
832     case SSL_ST_READ_DONE:
833         str = "RD";
834         break;
835     default:
836         str = "unknown";
837         break;
838     }
839     return (str);
840 }