ssl_stat.c revision 280304 
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
88const 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#ifndef OPENSSL_NO_SSL2
121    case SSL2_ST_CLIENT_START_ENCRYPTION:
122        str = "SSLv2 client start encryption";
123        break;
124    case SSL2_ST_SERVER_START_ENCRYPTION:
125        str = "SSLv2 server start encryption";
126        break;
127    case SSL2_ST_SEND_CLIENT_HELLO_A:
128        str = "SSLv2 write client hello A";
129        break;
130    case SSL2_ST_SEND_CLIENT_HELLO_B:
131        str = "SSLv2 write client hello B";
132        break;
133    case SSL2_ST_GET_SERVER_HELLO_A:
134        str = "SSLv2 read server hello A";
135        break;
136    case SSL2_ST_GET_SERVER_HELLO_B:
137        str = "SSLv2 read server hello B";
138        break;
139    case SSL2_ST_SEND_CLIENT_MASTER_KEY_A:
140        str = "SSLv2 write client master key A";
141        break;
142    case SSL2_ST_SEND_CLIENT_MASTER_KEY_B:
143        str = "SSLv2 write client master key B";
144        break;
145    case SSL2_ST_SEND_CLIENT_FINISHED_A:
146        str = "SSLv2 write client finished A";
147        break;
148    case SSL2_ST_SEND_CLIENT_FINISHED_B:
149        str = "SSLv2 write client finished B";
150        break;
151    case SSL2_ST_SEND_CLIENT_CERTIFICATE_A:
152        str = "SSLv2 write client certificate A";
153        break;
154    case SSL2_ST_SEND_CLIENT_CERTIFICATE_B:
155        str = "SSLv2 write client certificate B";
156        break;
157    case SSL2_ST_SEND_CLIENT_CERTIFICATE_C:
158        str = "SSLv2 write client certificate C";
159        break;
160    case SSL2_ST_SEND_CLIENT_CERTIFICATE_D:
161        str = "SSLv2 write client certificate D";
162        break;
163    case SSL2_ST_GET_SERVER_VERIFY_A:
164        str = "SSLv2 read server verify A";
165        break;
166    case SSL2_ST_GET_SERVER_VERIFY_B:
167        str = "SSLv2 read server verify B";
168        break;
169    case SSL2_ST_GET_SERVER_FINISHED_A:
170        str = "SSLv2 read server finished A";
171        break;
172    case SSL2_ST_GET_SERVER_FINISHED_B:
173        str = "SSLv2 read server finished B";
174        break;
175    case SSL2_ST_GET_CLIENT_HELLO_A:
176        str = "SSLv2 read client hello A";
177        break;
178    case SSL2_ST_GET_CLIENT_HELLO_B:
179        str = "SSLv2 read client hello B";
180        break;
181    case SSL2_ST_GET_CLIENT_HELLO_C:
182        str = "SSLv2 read client hello C";
183        break;
184    case SSL2_ST_SEND_SERVER_HELLO_A:
185        str = "SSLv2 write server hello A";
186        break;
187    case SSL2_ST_SEND_SERVER_HELLO_B:
188        str = "SSLv2 write server hello B";
189        break;
190    case SSL2_ST_GET_CLIENT_MASTER_KEY_A:
191        str = "SSLv2 read client master key A";
192        break;
193    case SSL2_ST_GET_CLIENT_MASTER_KEY_B:
194        str = "SSLv2 read client master key B";
195        break;
196    case SSL2_ST_SEND_SERVER_VERIFY_A:
197        str = "SSLv2 write server verify A";
198        break;
199    case SSL2_ST_SEND_SERVER_VERIFY_B:
200        str = "SSLv2 write server verify B";
201        break;
202    case SSL2_ST_SEND_SERVER_VERIFY_C:
203        str = "SSLv2 write server verify C";
204        break;
205    case SSL2_ST_GET_CLIENT_FINISHED_A:
206        str = "SSLv2 read client finished A";
207        break;
208    case SSL2_ST_GET_CLIENT_FINISHED_B:
209        str = "SSLv2 read client finished B";
210        break;
211    case SSL2_ST_SEND_SERVER_FINISHED_A:
212        str = "SSLv2 write server finished A";
213        break;
214    case SSL2_ST_SEND_SERVER_FINISHED_B:
215        str = "SSLv2 write server finished B";
216        break;
217    case SSL2_ST_SEND_REQUEST_CERTIFICATE_A:
218        str = "SSLv2 write request certificate A";
219        break;
220    case SSL2_ST_SEND_REQUEST_CERTIFICATE_B:
221        str = "SSLv2 write request certificate B";
222        break;
223    case SSL2_ST_SEND_REQUEST_CERTIFICATE_C:
224        str = "SSLv2 write request certificate C";
225        break;
226    case SSL2_ST_SEND_REQUEST_CERTIFICATE_D:
227        str = "SSLv2 write request certificate D";
228        break;
229    case SSL2_ST_X509_GET_SERVER_CERTIFICATE:
230        str = "SSLv2 X509 read server certificate";
231        break;
232    case SSL2_ST_X509_GET_CLIENT_CERTIFICATE:
233        str = "SSLv2 X509 read client certificate";
234        break;
235#endif
236
237#ifndef OPENSSL_NO_SSL3
238/* SSLv3 additions */
239    case SSL3_ST_CW_CLNT_HELLO_A:
240        str = "SSLv3 write client hello A";
241        break;
242    case SSL3_ST_CW_CLNT_HELLO_B:
243        str = "SSLv3 write client hello B";
244        break;
245    case SSL3_ST_CR_SRVR_HELLO_A:
246        str = "SSLv3 read server hello A";
247        break;
248    case SSL3_ST_CR_SRVR_HELLO_B:
249        str = "SSLv3 read server hello B";
250        break;
251    case SSL3_ST_CR_CERT_A:
252        str = "SSLv3 read server certificate A";
253        break;
254    case SSL3_ST_CR_CERT_B:
255        str = "SSLv3 read server certificate B";
256        break;
257    case SSL3_ST_CR_KEY_EXCH_A:
258        str = "SSLv3 read server key exchange A";
259        break;
260    case SSL3_ST_CR_KEY_EXCH_B:
261        str = "SSLv3 read server key exchange B";
262        break;
263    case SSL3_ST_CR_CERT_REQ_A:
264        str = "SSLv3 read server certificate request A";
265        break;
266    case SSL3_ST_CR_CERT_REQ_B:
267        str = "SSLv3 read server certificate request B";
268        break;
269    case SSL3_ST_CR_SESSION_TICKET_A:
270        str = "SSLv3 read server session ticket A";
271        break;
272    case SSL3_ST_CR_SESSION_TICKET_B:
273        str = "SSLv3 read server session ticket B";
274        break;
275    case SSL3_ST_CR_SRVR_DONE_A:
276        str = "SSLv3 read server done A";
277        break;
278    case SSL3_ST_CR_SRVR_DONE_B:
279        str = "SSLv3 read server done B";
280        break;
281    case SSL3_ST_CW_CERT_A:
282        str = "SSLv3 write client certificate A";
283        break;
284    case SSL3_ST_CW_CERT_B:
285        str = "SSLv3 write client certificate B";
286        break;
287    case SSL3_ST_CW_CERT_C:
288        str = "SSLv3 write client certificate C";
289        break;
290    case SSL3_ST_CW_CERT_D:
291        str = "SSLv3 write client certificate D";
292        break;
293    case SSL3_ST_CW_KEY_EXCH_A:
294        str = "SSLv3 write client key exchange A";
295        break;
296    case SSL3_ST_CW_KEY_EXCH_B:
297        str = "SSLv3 write client key exchange B";
298        break;
299    case SSL3_ST_CW_CERT_VRFY_A:
300        str = "SSLv3 write certificate verify A";
301        break;
302    case SSL3_ST_CW_CERT_VRFY_B:
303        str = "SSLv3 write certificate verify B";
304        break;
305
306    case SSL3_ST_CW_CHANGE_A:
307    case SSL3_ST_SW_CHANGE_A:
308        str = "SSLv3 write change cipher spec A";
309        break;
310    case SSL3_ST_CW_CHANGE_B:
311    case SSL3_ST_SW_CHANGE_B:
312        str = "SSLv3 write change cipher spec B";
313        break;
314    case SSL3_ST_CW_FINISHED_A:
315    case SSL3_ST_SW_FINISHED_A:
316        str = "SSLv3 write finished A";
317        break;
318    case SSL3_ST_CW_FINISHED_B:
319    case SSL3_ST_SW_FINISHED_B:
320        str = "SSLv3 write finished B";
321        break;
322    case SSL3_ST_CR_CHANGE_A:
323    case SSL3_ST_SR_CHANGE_A:
324        str = "SSLv3 read change cipher spec A";
325        break;
326    case SSL3_ST_CR_CHANGE_B:
327    case SSL3_ST_SR_CHANGE_B:
328        str = "SSLv3 read change cipher spec B";
329        break;
330    case SSL3_ST_CR_FINISHED_A:
331    case SSL3_ST_SR_FINISHED_A:
332        str = "SSLv3 read finished A";
333        break;
334    case SSL3_ST_CR_FINISHED_B:
335    case SSL3_ST_SR_FINISHED_B:
336        str = "SSLv3 read finished B";
337        break;
338
339    case SSL3_ST_CW_FLUSH:
340    case SSL3_ST_SW_FLUSH:
341        str = "SSLv3 flush data";
342        break;
343
344    case SSL3_ST_SR_CLNT_HELLO_A:
345        str = "SSLv3 read client hello A";
346        break;
347    case SSL3_ST_SR_CLNT_HELLO_B:
348        str = "SSLv3 read client hello B";
349        break;
350    case SSL3_ST_SR_CLNT_HELLO_C:
351        str = "SSLv3 read client hello C";
352        break;
353    case SSL3_ST_SW_HELLO_REQ_A:
354        str = "SSLv3 write hello request A";
355        break;
356    case SSL3_ST_SW_HELLO_REQ_B:
357        str = "SSLv3 write hello request B";
358        break;
359    case SSL3_ST_SW_HELLO_REQ_C:
360        str = "SSLv3 write hello request C";
361        break;
362    case SSL3_ST_SW_SRVR_HELLO_A:
363        str = "SSLv3 write server hello A";
364        break;
365    case SSL3_ST_SW_SRVR_HELLO_B:
366        str = "SSLv3 write server hello B";
367        break;
368    case SSL3_ST_SW_CERT_A:
369        str = "SSLv3 write certificate A";
370        break;
371    case SSL3_ST_SW_CERT_B:
372        str = "SSLv3 write certificate B";
373        break;
374    case SSL3_ST_SW_KEY_EXCH_A:
375        str = "SSLv3 write key exchange A";
376        break;
377    case SSL3_ST_SW_KEY_EXCH_B:
378        str = "SSLv3 write key exchange B";
379        break;
380    case SSL3_ST_SW_CERT_REQ_A:
381        str = "SSLv3 write certificate request A";
382        break;
383    case SSL3_ST_SW_CERT_REQ_B:
384        str = "SSLv3 write certificate request B";
385        break;
386    case SSL3_ST_SW_SESSION_TICKET_A:
387        str = "SSLv3 write session ticket A";
388        break;
389    case SSL3_ST_SW_SESSION_TICKET_B:
390        str = "SSLv3 write session ticket B";
391        break;
392    case SSL3_ST_SW_SRVR_DONE_A:
393        str = "SSLv3 write server done A";
394        break;
395    case SSL3_ST_SW_SRVR_DONE_B:
396        str = "SSLv3 write server done B";
397        break;
398    case SSL3_ST_SR_CERT_A:
399        str = "SSLv3 read client certificate A";
400        break;
401    case SSL3_ST_SR_CERT_B:
402        str = "SSLv3 read client certificate B";
403        break;
404    case SSL3_ST_SR_KEY_EXCH_A:
405        str = "SSLv3 read client key exchange A";
406        break;
407    case SSL3_ST_SR_KEY_EXCH_B:
408        str = "SSLv3 read client key exchange B";
409        break;
410    case SSL3_ST_SR_CERT_VRFY_A:
411        str = "SSLv3 read certificate verify A";
412        break;
413    case SSL3_ST_SR_CERT_VRFY_B:
414        str = "SSLv3 read certificate verify B";
415        break;
416#endif
417
418/* SSLv2/v3 compatibility states */
419/* client */
420    case SSL23_ST_CW_CLNT_HELLO_A:
421        str = "SSLv2/v3 write client hello A";
422        break;
423    case SSL23_ST_CW_CLNT_HELLO_B:
424        str = "SSLv2/v3 write client hello B";
425        break;
426    case SSL23_ST_CR_SRVR_HELLO_A:
427        str = "SSLv2/v3 read server hello A";
428        break;
429    case SSL23_ST_CR_SRVR_HELLO_B:
430        str = "SSLv2/v3 read server hello B";
431        break;
432/* server */
433    case SSL23_ST_SR_CLNT_HELLO_A:
434        str = "SSLv2/v3 read client hello A";
435        break;
436    case SSL23_ST_SR_CLNT_HELLO_B:
437        str = "SSLv2/v3 read client hello B";
438        break;
439
440/* DTLS */
441    case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A:
442        str = "DTLS1 read hello verify request A";
443        break;
444    case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B:
445        str = "DTLS1 read hello verify request B";
446        break;
447    case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A:
448        str = "DTLS1 write hello verify request A";
449        break;
450    case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B:
451        str = "DTLS1 write hello verify request B";
452        break;
453
454    default:
455        str = "unknown state";
456        break;
457    }
458    return (str);
459}
460
461const char *SSL_rstate_string_long(const SSL *s)
462{
463    const char *str;
464
465    switch (s->rstate) {
466    case SSL_ST_READ_HEADER:
467        str = "read header";
468        break;
469    case SSL_ST_READ_BODY:
470        str = "read body";
471        break;
472    case SSL_ST_READ_DONE:
473        str = "read done";
474        break;
475    default:
476        str = "unknown";
477        break;
478    }
479    return (str);
480}
481
482const char *SSL_state_string(const SSL *s)
483{
484    const char *str;
485
486    switch (s->state) {
487    case SSL_ST_BEFORE:
488        str = "PINIT ";
489        break;
490    case SSL_ST_ACCEPT:
491        str = "AINIT ";
492        break;
493    case SSL_ST_CONNECT:
494        str = "CINIT ";
495        break;
496    case SSL_ST_OK:
497        str = "SSLOK ";
498        break;
499#ifndef OPENSSL_NO_SSL2
500    case SSL2_ST_CLIENT_START_ENCRYPTION:
501        str = "2CSENC";
502        break;
503    case SSL2_ST_SERVER_START_ENCRYPTION:
504        str = "2SSENC";
505        break;
506    case SSL2_ST_SEND_CLIENT_HELLO_A:
507        str = "2SCH_A";
508        break;
509    case SSL2_ST_SEND_CLIENT_HELLO_B:
510        str = "2SCH_B";
511        break;
512    case SSL2_ST_GET_SERVER_HELLO_A:
513        str = "2GSH_A";
514        break;
515    case SSL2_ST_GET_SERVER_HELLO_B:
516        str = "2GSH_B";
517        break;
518    case SSL2_ST_SEND_CLIENT_MASTER_KEY_A:
519        str = "2SCMKA";
520        break;
521    case SSL2_ST_SEND_CLIENT_MASTER_KEY_B:
522        str = "2SCMKB";
523        break;
524    case SSL2_ST_SEND_CLIENT_FINISHED_A:
525        str = "2SCF_A";
526        break;
527    case SSL2_ST_SEND_CLIENT_FINISHED_B:
528        str = "2SCF_B";
529        break;
530    case SSL2_ST_SEND_CLIENT_CERTIFICATE_A:
531        str = "2SCC_A";
532        break;
533    case SSL2_ST_SEND_CLIENT_CERTIFICATE_B:
534        str = "2SCC_B";
535        break;
536    case SSL2_ST_SEND_CLIENT_CERTIFICATE_C:
537        str = "2SCC_C";
538        break;
539    case SSL2_ST_SEND_CLIENT_CERTIFICATE_D:
540        str = "2SCC_D";
541        break;
542    case SSL2_ST_GET_SERVER_VERIFY_A:
543        str = "2GSV_A";
544        break;
545    case SSL2_ST_GET_SERVER_VERIFY_B:
546        str = "2GSV_B";
547        break;
548    case SSL2_ST_GET_SERVER_FINISHED_A:
549        str = "2GSF_A";
550        break;
551    case SSL2_ST_GET_SERVER_FINISHED_B:
552        str = "2GSF_B";
553        break;
554    case SSL2_ST_GET_CLIENT_HELLO_A:
555        str = "2GCH_A";
556        break;
557    case SSL2_ST_GET_CLIENT_HELLO_B:
558        str = "2GCH_B";
559        break;
560    case SSL2_ST_GET_CLIENT_HELLO_C:
561        str = "2GCH_C";
562        break;
563    case SSL2_ST_SEND_SERVER_HELLO_A:
564        str = "2SSH_A";
565        break;
566    case SSL2_ST_SEND_SERVER_HELLO_B:
567        str = "2SSH_B";
568        break;
569    case SSL2_ST_GET_CLIENT_MASTER_KEY_A:
570        str = "2GCMKA";
571        break;
572    case SSL2_ST_GET_CLIENT_MASTER_KEY_B:
573        str = "2GCMKA";
574        break;
575    case SSL2_ST_SEND_SERVER_VERIFY_A:
576        str = "2SSV_A";
577        break;
578    case SSL2_ST_SEND_SERVER_VERIFY_B:
579        str = "2SSV_B";
580        break;
581    case SSL2_ST_SEND_SERVER_VERIFY_C:
582        str = "2SSV_C";
583        break;
584    case SSL2_ST_GET_CLIENT_FINISHED_A:
585        str = "2GCF_A";
586        break;
587    case SSL2_ST_GET_CLIENT_FINISHED_B:
588        str = "2GCF_B";
589        break;
590    case SSL2_ST_SEND_SERVER_FINISHED_A:
591        str = "2SSF_A";
592        break;
593    case SSL2_ST_SEND_SERVER_FINISHED_B:
594        str = "2SSF_B";
595        break;
596    case SSL2_ST_SEND_REQUEST_CERTIFICATE_A:
597        str = "2SRC_A";
598        break;
599    case SSL2_ST_SEND_REQUEST_CERTIFICATE_B:
600        str = "2SRC_B";
601        break;
602    case SSL2_ST_SEND_REQUEST_CERTIFICATE_C:
603        str = "2SRC_C";
604        break;
605    case SSL2_ST_SEND_REQUEST_CERTIFICATE_D:
606        str = "2SRC_D";
607        break;
608    case SSL2_ST_X509_GET_SERVER_CERTIFICATE:
609        str = "2X9GSC";
610        break;
611    case SSL2_ST_X509_GET_CLIENT_CERTIFICATE:
612        str = "2X9GCC";
613        break;
614#endif
615
616#ifndef OPENSSL_NO_SSL3
617/* SSLv3 additions */
618    case SSL3_ST_SW_FLUSH:
619    case SSL3_ST_CW_FLUSH:
620        str = "3FLUSH";
621        break;
622    case SSL3_ST_CW_CLNT_HELLO_A:
623        str = "3WCH_A";
624        break;
625    case SSL3_ST_CW_CLNT_HELLO_B:
626        str = "3WCH_B";
627        break;
628    case SSL3_ST_CR_SRVR_HELLO_A:
629        str = "3RSH_A";
630        break;
631    case SSL3_ST_CR_SRVR_HELLO_B:
632        str = "3RSH_B";
633        break;
634    case SSL3_ST_CR_CERT_A:
635        str = "3RSC_A";
636        break;
637    case SSL3_ST_CR_CERT_B:
638        str = "3RSC_B";
639        break;
640    case SSL3_ST_CR_KEY_EXCH_A:
641        str = "3RSKEA";
642        break;
643    case SSL3_ST_CR_KEY_EXCH_B:
644        str = "3RSKEB";
645        break;
646    case SSL3_ST_CR_CERT_REQ_A:
647        str = "3RCR_A";
648        break;
649    case SSL3_ST_CR_CERT_REQ_B:
650        str = "3RCR_B";
651        break;
652    case SSL3_ST_CR_SRVR_DONE_A:
653        str = "3RSD_A";
654        break;
655    case SSL3_ST_CR_SRVR_DONE_B:
656        str = "3RSD_B";
657        break;
658    case SSL3_ST_CW_CERT_A:
659        str = "3WCC_A";
660        break;
661    case SSL3_ST_CW_CERT_B:
662        str = "3WCC_B";
663        break;
664    case SSL3_ST_CW_CERT_C:
665        str = "3WCC_C";
666        break;
667    case SSL3_ST_CW_CERT_D:
668        str = "3WCC_D";
669        break;
670    case SSL3_ST_CW_KEY_EXCH_A:
671        str = "3WCKEA";
672        break;
673    case SSL3_ST_CW_KEY_EXCH_B:
674        str = "3WCKEB";
675        break;
676    case SSL3_ST_CW_CERT_VRFY_A:
677        str = "3WCV_A";
678        break;
679    case SSL3_ST_CW_CERT_VRFY_B:
680        str = "3WCV_B";
681        break;
682
683    case SSL3_ST_SW_CHANGE_A:
684    case SSL3_ST_CW_CHANGE_A:
685        str = "3WCCSA";
686        break;
687    case SSL3_ST_SW_CHANGE_B:
688    case SSL3_ST_CW_CHANGE_B:
689        str = "3WCCSB";
690        break;
691    case SSL3_ST_SW_FINISHED_A:
692    case SSL3_ST_CW_FINISHED_A:
693        str = "3WFINA";
694        break;
695    case SSL3_ST_SW_FINISHED_B:
696    case SSL3_ST_CW_FINISHED_B:
697        str = "3WFINB";
698        break;
699    case SSL3_ST_SR_CHANGE_A:
700    case SSL3_ST_CR_CHANGE_A:
701        str = "3RCCSA";
702        break;
703    case SSL3_ST_SR_CHANGE_B:
704    case SSL3_ST_CR_CHANGE_B:
705        str = "3RCCSB";
706        break;
707    case SSL3_ST_SR_FINISHED_A:
708    case SSL3_ST_CR_FINISHED_A:
709        str = "3RFINA";
710        break;
711    case SSL3_ST_SR_FINISHED_B:
712    case SSL3_ST_CR_FINISHED_B:
713        str = "3RFINB";
714        break;
715
716    case SSL3_ST_SW_HELLO_REQ_A:
717        str = "3WHR_A";
718        break;
719    case SSL3_ST_SW_HELLO_REQ_B:
720        str = "3WHR_B";
721        break;
722    case SSL3_ST_SW_HELLO_REQ_C:
723        str = "3WHR_C";
724        break;
725    case SSL3_ST_SR_CLNT_HELLO_A:
726        str = "3RCH_A";
727        break;
728    case SSL3_ST_SR_CLNT_HELLO_B:
729        str = "3RCH_B";
730        break;
731    case SSL3_ST_SR_CLNT_HELLO_C:
732        str = "3RCH_C";
733        break;
734    case SSL3_ST_SW_SRVR_HELLO_A:
735        str = "3WSH_A";
736        break;
737    case SSL3_ST_SW_SRVR_HELLO_B:
738        str = "3WSH_B";
739        break;
740    case SSL3_ST_SW_CERT_A:
741        str = "3WSC_A";
742        break;
743    case SSL3_ST_SW_CERT_B:
744        str = "3WSC_B";
745        break;
746    case SSL3_ST_SW_KEY_EXCH_A:
747        str = "3WSKEA";
748        break;
749    case SSL3_ST_SW_KEY_EXCH_B:
750        str = "3WSKEB";
751        break;
752    case SSL3_ST_SW_CERT_REQ_A:
753        str = "3WCR_A";
754        break;
755    case SSL3_ST_SW_CERT_REQ_B:
756        str = "3WCR_B";
757        break;
758    case SSL3_ST_SW_SRVR_DONE_A:
759        str = "3WSD_A";
760        break;
761    case SSL3_ST_SW_SRVR_DONE_B:
762        str = "3WSD_B";
763        break;
764    case SSL3_ST_SR_CERT_A:
765        str = "3RCC_A";
766        break;
767    case SSL3_ST_SR_CERT_B:
768        str = "3RCC_B";
769        break;
770    case SSL3_ST_SR_KEY_EXCH_A:
771        str = "3RCKEA";
772        break;
773    case SSL3_ST_SR_KEY_EXCH_B:
774        str = "3RCKEB";
775        break;
776    case SSL3_ST_SR_CERT_VRFY_A:
777        str = "3RCV_A";
778        break;
779    case SSL3_ST_SR_CERT_VRFY_B:
780        str = "3RCV_B";
781        break;
782#endif
783
784/* SSLv2/v3 compatibility states */
785/* client */
786    case SSL23_ST_CW_CLNT_HELLO_A:
787        str = "23WCHA";
788        break;
789    case SSL23_ST_CW_CLNT_HELLO_B:
790        str = "23WCHB";
791        break;
792    case SSL23_ST_CR_SRVR_HELLO_A:
793        str = "23RSHA";
794        break;
795    case SSL23_ST_CR_SRVR_HELLO_B:
796        str = "23RSHA";
797        break;
798/* server */
799    case SSL23_ST_SR_CLNT_HELLO_A:
800        str = "23RCHA";
801        break;
802    case SSL23_ST_SR_CLNT_HELLO_B:
803        str = "23RCHB";
804        break;
805
806/* DTLS */
807    case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_A:
808        str = "DRCHVA";
809        break;
810    case DTLS1_ST_CR_HELLO_VERIFY_REQUEST_B:
811        str = "DRCHVB";
812        break;
813    case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_A:
814        str = "DWCHVA";
815        break;
816    case DTLS1_ST_SW_HELLO_VERIFY_REQUEST_B:
817        str = "DWCHVB";
818        break;
819
820    default:
821        str = "UNKWN ";
822        break;
823    }
824    return (str);
825}
826
827const char *SSL_alert_type_string_long(int value)
828{
829    value >>= 8;
830    if (value == SSL3_AL_WARNING)
831        return ("warning");
832    else if (value == SSL3_AL_FATAL)
833        return ("fatal");
834    else
835        return ("unknown");
836}
837
838const char *SSL_alert_type_string(int value)
839{
840    value >>= 8;
841    if (value == SSL3_AL_WARNING)
842        return ("W");
843    else if (value == SSL3_AL_FATAL)
844        return ("F");
845    else
846        return ("U");
847}
848
849const char *SSL_alert_desc_string(int value)
850{
851    const char *str;
852
853    switch (value & 0xff) {
854    case SSL3_AD_CLOSE_NOTIFY:
855        str = "CN";
856        break;
857    case SSL3_AD_UNEXPECTED_MESSAGE:
858        str = "UM";
859        break;
860    case SSL3_AD_BAD_RECORD_MAC:
861        str = "BM";
862        break;
863    case SSL3_AD_DECOMPRESSION_FAILURE:
864        str = "DF";
865        break;
866    case SSL3_AD_HANDSHAKE_FAILURE:
867        str = "HF";
868        break;
869    case SSL3_AD_NO_CERTIFICATE:
870        str = "NC";
871        break;
872    case SSL3_AD_BAD_CERTIFICATE:
873        str = "BC";
874        break;
875    case SSL3_AD_UNSUPPORTED_CERTIFICATE:
876        str = "UC";
877        break;
878    case SSL3_AD_CERTIFICATE_REVOKED:
879        str = "CR";
880        break;
881    case SSL3_AD_CERTIFICATE_EXPIRED:
882        str = "CE";
883        break;
884    case SSL3_AD_CERTIFICATE_UNKNOWN:
885        str = "CU";
886        break;
887    case SSL3_AD_ILLEGAL_PARAMETER:
888        str = "IP";
889        break;
890    case TLS1_AD_DECRYPTION_FAILED:
891        str = "DC";
892        break;
893    case TLS1_AD_RECORD_OVERFLOW:
894        str = "RO";
895        break;
896    case TLS1_AD_UNKNOWN_CA:
897        str = "CA";
898        break;
899    case TLS1_AD_ACCESS_DENIED:
900        str = "AD";
901        break;
902    case TLS1_AD_DECODE_ERROR:
903        str = "DE";
904        break;
905    case TLS1_AD_DECRYPT_ERROR:
906        str = "CY";
907        break;
908    case TLS1_AD_EXPORT_RESTRICTION:
909        str = "ER";
910        break;
911    case TLS1_AD_PROTOCOL_VERSION:
912        str = "PV";
913        break;
914    case TLS1_AD_INSUFFICIENT_SECURITY:
915        str = "IS";
916        break;
917    case TLS1_AD_INTERNAL_ERROR:
918        str = "IE";
919        break;
920    case TLS1_AD_USER_CANCELLED:
921        str = "US";
922        break;
923    case TLS1_AD_NO_RENEGOTIATION:
924        str = "NR";
925        break;
926    case TLS1_AD_UNSUPPORTED_EXTENSION:
927        str = "UE";
928        break;
929    case TLS1_AD_CERTIFICATE_UNOBTAINABLE:
930        str = "CO";
931        break;
932    case TLS1_AD_UNRECOGNIZED_NAME:
933        str = "UN";
934        break;
935    case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
936        str = "BR";
937        break;
938    case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE:
939        str = "BH";
940        break;
941    case TLS1_AD_UNKNOWN_PSK_IDENTITY:
942        str = "UP";
943        break;
944    default:
945        str = "UK";
946        break;
947    }
948    return (str);
949}
950
951const char *SSL_alert_desc_string_long(int value)
952{
953    const char *str;
954
955    switch (value & 0xff) {
956    case SSL3_AD_CLOSE_NOTIFY:
957        str = "close notify";
958        break;
959    case SSL3_AD_UNEXPECTED_MESSAGE:
960        str = "unexpected_message";
961        break;
962    case SSL3_AD_BAD_RECORD_MAC:
963        str = "bad record mac";
964        break;
965    case SSL3_AD_DECOMPRESSION_FAILURE:
966        str = "decompression failure";
967        break;
968    case SSL3_AD_HANDSHAKE_FAILURE:
969        str = "handshake failure";
970        break;
971    case SSL3_AD_NO_CERTIFICATE:
972        str = "no certificate";
973        break;
974    case SSL3_AD_BAD_CERTIFICATE:
975        str = "bad certificate";
976        break;
977    case SSL3_AD_UNSUPPORTED_CERTIFICATE:
978        str = "unsupported certificate";
979        break;
980    case SSL3_AD_CERTIFICATE_REVOKED:
981        str = "certificate revoked";
982        break;
983    case SSL3_AD_CERTIFICATE_EXPIRED:
984        str = "certificate expired";
985        break;
986    case SSL3_AD_CERTIFICATE_UNKNOWN:
987        str = "certificate unknown";
988        break;
989    case SSL3_AD_ILLEGAL_PARAMETER:
990        str = "illegal parameter";
991        break;
992    case TLS1_AD_DECRYPTION_FAILED:
993        str = "decryption failed";
994        break;
995    case TLS1_AD_RECORD_OVERFLOW:
996        str = "record overflow";
997        break;
998    case TLS1_AD_UNKNOWN_CA:
999        str = "unknown CA";
1000        break;
1001    case TLS1_AD_ACCESS_DENIED:
1002        str = "access denied";
1003        break;
1004    case TLS1_AD_DECODE_ERROR:
1005        str = "decode error";
1006        break;
1007    case TLS1_AD_DECRYPT_ERROR:
1008        str = "decrypt error";
1009        break;
1010    case TLS1_AD_EXPORT_RESTRICTION:
1011        str = "export restriction";
1012        break;
1013    case TLS1_AD_PROTOCOL_VERSION:
1014        str = "protocol version";
1015        break;
1016    case TLS1_AD_INSUFFICIENT_SECURITY:
1017        str = "insufficient security";
1018        break;
1019    case TLS1_AD_INTERNAL_ERROR:
1020        str = "internal error";
1021        break;
1022    case TLS1_AD_USER_CANCELLED:
1023        str = "user canceled";
1024        break;
1025    case TLS1_AD_NO_RENEGOTIATION:
1026        str = "no renegotiation";
1027        break;
1028    case TLS1_AD_UNSUPPORTED_EXTENSION:
1029        str = "unsupported extension";
1030        break;
1031    case TLS1_AD_CERTIFICATE_UNOBTAINABLE:
1032        str = "certificate unobtainable";
1033        break;
1034    case TLS1_AD_UNRECOGNIZED_NAME:
1035        str = "unrecognized name";
1036        break;
1037    case TLS1_AD_BAD_CERTIFICATE_STATUS_RESPONSE:
1038        str = "bad certificate status response";
1039        break;
1040    case TLS1_AD_BAD_CERTIFICATE_HASH_VALUE:
1041        str = "bad certificate hash value";
1042        break;
1043    case TLS1_AD_UNKNOWN_PSK_IDENTITY:
1044        str = "unknown PSK identity";
1045        break;
1046    default:
1047        str = "unknown";
1048        break;
1049    }
1050    return (str);
1051}
1052
1053const char *SSL_rstate_string(const SSL *s)
1054{
1055    const char *str;
1056
1057    switch (s->rstate) {
1058    case SSL_ST_READ_HEADER:
1059        str = "RH";
1060        break;
1061    case SSL_ST_READ_BODY:
1062        str = "RB";
1063        break;
1064    case SSL_ST_READ_DONE:
1065        str = "RD";
1066        break;
1067    default:
1068        str = "unknown";
1069        break;
1070    }
1071    return (str);
1072}
1073