← Back to branch summary

~ubuntu-branches/ubuntu/hardy/openssl/hardy-security

« back to all changes in this revision

Viewing changes to ssl/ssl_locl.h

  • Committer: Bazaar Package Importer
  • Author(s): Kurt Roeckx
  • Date: 2005-12-13 21:37:42 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051213213742-7em5nrw5c7ceegyd
Tags: 0.9.8a-5
http://bugs.debian.org/335912
Stop ssh from crashing randomly on sparc (Closes: #335912)
Patch from upstream cvs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ssl/ssl_locl.h
108
108
 * Hudson (tjh@cryptsoft.com).
109
109
 *
110
110
 */
 
111
/* ====================================================================
 
112
 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
 
113
 * ECC cipher suite support in OpenSSL originally developed by 
 
114
 * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
 
115
 */
111
116
 
112
117
#ifndef HEADER_SSL_LOCL_H
113
118
#define HEADER_SSL_LOCL_H
121
126
#include <openssl/buffer.h>
122
127
#include <openssl/comp.h>
123
128
#include <openssl/bio.h>
124
 
#include <openssl/crypto.h>
125
 
#include <openssl/evp.h>
126
129
#include <openssl/stack.h>
127
 
#include <openssl/x509.h>
 
130
#ifndef OPENSSL_NO_RSA
 
131
#include <openssl/rsa.h>
 
132
#endif
 
133
#ifndef OPENSSL_NO_DSA
 
134
#include <openssl/dsa.h>
 
135
#endif
128
136
#include <openssl/err.h>
129
137
#include <openssl/ssl.h>
130
138
#include <openssl/symhacks.h>
172
180
                         *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
173
181
                         *((c)++)=(unsigned char)(((l)    )&0xff))
174
182
 
 
183
#define l2n6(l,c)       (*((c)++)=(unsigned char)(((l)>>40)&0xff), \
 
184
                         *((c)++)=(unsigned char)(((l)>>32)&0xff), \
 
185
                         *((c)++)=(unsigned char)(((l)>>24)&0xff), \
 
186
                         *((c)++)=(unsigned char)(((l)>>16)&0xff), \
 
187
                         *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
 
188
                         *((c)++)=(unsigned char)(((l)    )&0xff))
 
189
 
 
190
#define n2l6(c,l)       (l =((BN_ULLONG)(*((c)++)))<<40, \
 
191
                         l|=((BN_ULLONG)(*((c)++)))<<32, \
 
192
                         l|=((BN_ULLONG)(*((c)++)))<<24, \
 
193
                         l|=((BN_ULLONG)(*((c)++)))<<16, \
 
194
                         l|=((BN_ULLONG)(*((c)++)))<< 8, \
 
195
                         l|=((BN_ULLONG)(*((c)++))))
 
196
 
175
197
/* NOTE - c is not incremented as per l2c */
176
198
#define l2cn(l1,l2,c,n) { \
177
199
                        c+=n; \
227
249
 * that the different entities within are mutually exclusive:
228
250
 * ONLY ONE BIT PER MASK CAN BE SET AT A TIME.
229
251
 */
230
 
#define SSL_MKEY_MASK           0x0000003FL
 
252
#define SSL_MKEY_MASK           0x000000FFL
231
253
#define SSL_kRSA                0x00000001L /* RSA key exchange */
232
254
#define SSL_kDHr                0x00000002L /* DH cert RSA CA cert */
233
255
#define SSL_kDHd                0x00000004L /* DH cert DSA CA cert */
234
256
#define SSL_kFZA                0x00000008L
235
257
#define SSL_kEDH                0x00000010L /* tmp DH key no DH cert */
236
258
#define SSL_kKRB5               0x00000020L /* Kerberos5 key exchange */
 
259
#define SSL_kECDH               0x00000040L /* ECDH w/ long-term keys */
 
260
#define SSL_kECDHE              0x00000080L /* ephemeral ECDH */
237
261
#define SSL_EDH                 (SSL_kEDH|(SSL_AUTH_MASK^SSL_aNULL))
238
262
 
239
 
#define SSL_AUTH_MASK           0x00000FC0L
240
 
#define SSL_aRSA                0x00000040L /* Authenticate with RSA */
241
 
#define SSL_aDSS                0x00000080L /* Authenticate with DSS */
 
263
#define SSL_AUTH_MASK           0x00007F00L
 
264
#define SSL_aRSA                0x00000100L /* Authenticate with RSA */
 
265
#define SSL_aDSS                0x00000200L /* Authenticate with DSS */
242
266
#define SSL_DSS                 SSL_aDSS
243
 
#define SSL_aFZA                0x00000100L
244
 
#define SSL_aNULL               0x00000200L /* no Authenticate, ADH */
245
 
#define SSL_aDH                 0x00000400L /* no Authenticate, ADH */
246
 
#define SSL_aKRB5               0x00000800L /* Authenticate with KRB5 */
 
267
#define SSL_aFZA                0x00000400L
 
268
#define SSL_aNULL               0x00000800L /* no Authenticate, ADH */
 
269
#define SSL_aDH                 0x00001000L /* no Authenticate, ADH */
 
270
#define SSL_aKRB5               0x00002000L /* Authenticate with KRB5 */
 
271
#define SSL_aECDSA              0x00004000L /* Authenticate with ECDSA */
247
272
 
248
273
#define SSL_NULL                (SSL_eNULL)
249
274
#define SSL_ADH                 (SSL_kEDH|SSL_aNULL)
250
275
#define SSL_RSA                 (SSL_kRSA|SSL_aRSA)
251
276
#define SSL_DH                  (SSL_kDHr|SSL_kDHd|SSL_kEDH)
 
277
#define SSL_ECDH                (SSL_kECDH|SSL_kECDHE)
252
278
#define SSL_FZA                 (SSL_aFZA|SSL_kFZA|SSL_eFZA)
253
279
#define SSL_KRB5                (SSL_kKRB5|SSL_aKRB5)
254
280
 
255
 
#define SSL_ENC_MASK            0x0087F000L
256
 
#define SSL_DES                 0x00001000L
257
 
#define SSL_3DES                0x00002000L
258
 
#define SSL_RC4                 0x00004000L
259
 
#define SSL_RC2                 0x00008000L
260
 
#define SSL_IDEA                0x00010000L
261
 
#define SSL_eFZA                0x00020000L
262
 
#define SSL_eNULL               0x00040000L
263
 
#define SSL_AES                 0x00800000L
 
281
#define SSL_ENC_MASK            0x043F8000L
 
282
#define SSL_DES                 0x00008000L
 
283
#define SSL_3DES                0x00010000L
 
284
#define SSL_RC4                 0x00020000L
 
285
#define SSL_RC2                 0x00040000L
 
286
#define SSL_IDEA                0x00080000L
 
287
#define SSL_eFZA                0x00100000L
 
288
#define SSL_eNULL               0x00200000L
 
289
#define SSL_AES                 0x04000000L
264
290
 
265
 
#define SSL_MAC_MASK            0x00180000L
266
 
#define SSL_MD5                 0x00080000L
267
 
#define SSL_SHA1                0x00100000L
 
291
#define SSL_MAC_MASK            0x00c00000L
 
292
#define SSL_MD5                 0x00400000L
 
293
#define SSL_SHA1                0x00800000L
268
294
#define SSL_SHA                 (SSL_SHA1)
269
295
 
270
 
#define SSL_SSL_MASK            0x00600000L
271
 
#define SSL_SSLV2               0x00200000L
272
 
#define SSL_SSLV3               0x00400000L
 
296
#define SSL_SSL_MASK            0x03000000L
 
297
#define SSL_SSLV2               0x01000000L
 
298
#define SSL_SSLV3               0x02000000L
273
299
#define SSL_TLSV1               SSL_SSLV3       /* for now */
274
300
 
275
 
/* we have used 007fffff - 9 bits left to go */
 
301
/* we have used 07ffffff - 5 bits left to go. */
276
302
 
277
303
/*
278
304
 * Export and cipher strength information. For each cipher we have to decide
302
328
#define SSL_LOW                 0x00000020L
303
329
#define SSL_MEDIUM              0x00000040L
304
330
#define SSL_HIGH                0x00000080L
305
 
#define SSL_FIPS                0x00000100L
306
331
 
307
 
/* we have used 000001ff - 23 bits left to go */
 
332
/* we have used 000000ff - 24 bits left to go */
308
333
 
309
334
/*
310
335
 * Macros to check the export status and cipher strength for export ciphers.
345
370
#define SSL_PKEY_DSA_SIGN       2
346
371
#define SSL_PKEY_DH_RSA         3
347
372
#define SSL_PKEY_DH_DSA         4
348
 
#define SSL_PKEY_NUM            5
 
373
#define SSL_PKEY_ECC            5
 
374
#define SSL_PKEY_NUM            6
349
375
 
350
376
/* SSL_kRSA <- RSA_ENC | (RSA_TMP & RSA_SIGN) |
351
377
 *          <- (EXPORT & (RSA_ENC | RSA_TMP) & RSA_SIGN)
361
387
#define CERT_PRIVATE_KEY        2
362
388
*/
363
389
 
 
390
#ifndef OPENSSL_NO_EC
 
391
/* From ECC-TLS draft, used in encoding the curve type in 
 
392
 * ECParameters
 
393
 */
 
394
#define EXPLICIT_PRIME_CURVE_TYPE  1   
 
395
#define EXPLICIT_CHAR2_CURVE_TYPE  2
 
396
#define NAMED_CURVE_TYPE           3
 
397
#endif  /* OPENSSL_NO_EC */
 
398
 
364
399
typedef struct cert_pkey_st
365
400
        {
366
401
        X509 *x509;
387
422
        DH *dh_tmp;
388
423
        DH *(*dh_tmp_cb)(SSL *ssl,int is_export,int keysize);
389
424
#endif
 
425
#ifndef OPENSSL_NO_ECDH
 
426
        EC_KEY *ecdh_tmp;
 
427
        /* Callback for generating ephemeral ECDH keys */
 
428
        EC_KEY *(*ecdh_tmp_cb)(SSL *ssl,int is_export,int keysize);
 
429
#endif
390
430
 
391
431
        CERT_PKEY pkeys[SSL_PKEY_NUM];
392
432
 
412
452
#ifndef OPENSSL_NO_DH
413
453
        DH *peer_dh_tmp; /* not used for SSL 2 */
414
454
#endif
 
455
#ifndef OPENSSL_NO_ECDH
 
456
        EC_KEY *peer_ecdh_tmp;
 
457
#endif
415
458
 
416
459
        int references; /* actually always 1 at the moment */
417
460
        } SESS_CERT;
462
505
        COMP_METHOD *method; /* The method :-) */
463
506
        } SSL3_COMP;
464
507
 
465
 
OPENSSL_EXTERN SSL3_ENC_METHOD ssl3_undef_enc_method;
 
508
extern SSL3_ENC_METHOD ssl3_undef_enc_method;
466
509
OPENSSL_EXTERN SSL_CIPHER ssl2_ciphers[];
467
510
OPENSSL_EXTERN SSL_CIPHER ssl3_ciphers[];
468
511
 
469
 
#ifdef OPENSSL_SYS_VMS
470
 
#undef SSL_COMP_get_compression_methods
471
 
#define SSL_COMP_get_compression_methods        SSL_COMP_get_compress_methods
472
 
#endif
473
 
 
474
512
 
475
513
SSL_METHOD *ssl_bad_method(int ver);
476
514
SSL_METHOD *sslv2_base_method(void);
477
515
SSL_METHOD *sslv23_base_method(void);
478
516
SSL_METHOD *sslv3_base_method(void);
479
517
 
 
518
extern SSL3_ENC_METHOD TLSv1_enc_data;
 
519
extern SSL3_ENC_METHOD SSLv3_enc_data;
 
520
extern SSL3_ENC_METHOD DTLSv1_enc_data;
 
521
 
 
522
#define IMPLEMENT_tls1_meth_func(func_name, s_accept, s_connect, s_get_meth) \
 
523
SSL_METHOD *func_name(void)  \
 
524
        { \
 
525
        static SSL_METHOD func_name##_data= { \
 
526
                TLS1_VERSION, \
 
527
                tls1_new, \
 
528
                tls1_clear, \
 
529
                tls1_free, \
 
530
                s_accept, \
 
531
                s_connect, \
 
532
                ssl3_read, \
 
533
                ssl3_peek, \
 
534
                ssl3_write, \
 
535
                ssl3_shutdown, \
 
536
                ssl3_renegotiate, \
 
537
                ssl3_renegotiate_check, \
 
538
                ssl3_get_message, \
 
539
                ssl3_read_bytes, \
 
540
                ssl3_write_bytes, \
 
541
                ssl3_dispatch_alert, \
 
542
                ssl3_ctrl, \
 
543
                ssl3_ctx_ctrl, \
 
544
                ssl3_get_cipher_by_char, \
 
545
                ssl3_put_cipher_by_char, \
 
546
                ssl3_pending, \
 
547
                ssl3_num_ciphers, \
 
548
                ssl3_get_cipher, \
 
549
                s_get_meth, \
 
550
                tls1_default_timeout, \
 
551
                &TLSv1_enc_data, \
 
552
                ssl_undefined_void_function, \
 
553
                ssl3_callback_ctrl, \
 
554
                ssl3_ctx_callback_ctrl, \
 
555
        }; \
 
556
        return &func_name##_data; \
 
557
        }
 
558
 
 
559
#define IMPLEMENT_ssl3_meth_func(func_name, s_accept, s_connect, s_get_meth) \
 
560
SSL_METHOD *func_name(void)  \
 
561
        { \
 
562
        static SSL_METHOD func_name##_data= { \
 
563
                SSL3_VERSION, \
 
564
                ssl3_new, \
 
565
                ssl3_clear, \
 
566
                ssl3_free, \
 
567
                s_accept, \
 
568
                s_connect, \
 
569
                ssl3_read, \
 
570
                ssl3_peek, \
 
571
                ssl3_write, \
 
572
                ssl3_shutdown, \
 
573
                ssl3_renegotiate, \
 
574
                ssl3_renegotiate_check, \
 
575
                ssl3_get_message, \
 
576
                ssl3_read_bytes, \
 
577
                ssl3_write_bytes, \
 
578
                ssl3_dispatch_alert, \
 
579
                ssl3_ctrl, \
 
580
                ssl3_ctx_ctrl, \
 
581
                ssl3_get_cipher_by_char, \
 
582
                ssl3_put_cipher_by_char, \
 
583
                ssl3_pending, \
 
584
                ssl3_num_ciphers, \
 
585
                ssl3_get_cipher, \
 
586
                s_get_meth, \
 
587
                ssl3_default_timeout, \
 
588
                &SSLv3_enc_data, \
 
589
                ssl_undefined_void_function, \
 
590
                ssl3_callback_ctrl, \
 
591
                ssl3_ctx_callback_ctrl, \
 
592
        }; \
 
593
        return &func_name##_data; \
 
594
        }
 
595
 
 
596
#define IMPLEMENT_ssl23_meth_func(func_name, s_accept, s_connect, s_get_meth) \
 
597
SSL_METHOD *func_name(void)  \
 
598
        { \
 
599
        static SSL_METHOD func_name##_data= { \
 
600
        TLS1_VERSION, \
 
601
        tls1_new, \
 
602
        tls1_clear, \
 
603
        tls1_free, \
 
604
        s_accept, \
 
605
        s_connect, \
 
606
        ssl23_read, \
 
607
        ssl23_peek, \
 
608
        ssl23_write, \
 
609
        ssl_undefined_function, \
 
610
        ssl_undefined_function, \
 
611
        ssl_ok, \
 
612
        ssl3_get_message, \
 
613
        ssl3_read_bytes, \
 
614
        ssl3_write_bytes, \
 
615
        ssl3_dispatch_alert, \
 
616
        ssl3_ctrl, \
 
617
        ssl3_ctx_ctrl, \
 
618
        ssl23_get_cipher_by_char, \
 
619
        ssl23_put_cipher_by_char, \
 
620
        ssl_undefined_const_function, \
 
621
        ssl23_num_ciphers, \
 
622
        ssl23_get_cipher, \
 
623
        s_get_meth, \
 
624
        ssl23_default_timeout, \
 
625
        &ssl3_undef_enc_method, \
 
626
        ssl_undefined_void_function, \
 
627
        ssl3_callback_ctrl, \
 
628
        ssl3_ctx_callback_ctrl, \
 
629
        }; \
 
630
        return &func_name##_data; \
 
631
        }
 
632
 
 
633
#define IMPLEMENT_ssl2_meth_func(func_name, s_accept, s_connect, s_get_meth) \
 
634
SSL_METHOD *func_name(void)  \
 
635
        { \
 
636
        static SSL_METHOD func_name##_data= { \
 
637
                SSL2_VERSION, \
 
638
                ssl2_new,       /* local */ \
 
639
                ssl2_clear,     /* local */ \
 
640
                ssl2_free,      /* local */ \
 
641
                s_accept, \
 
642
                s_connect, \
 
643
                ssl2_read, \
 
644
                ssl2_peek, \
 
645
                ssl2_write, \
 
646
                ssl2_shutdown, \
 
647
                ssl_ok, /* NULL - renegotiate */ \
 
648
                ssl_ok, /* NULL - check renegotiate */ \
 
649
                NULL, /* NULL - ssl_get_message */ \
 
650
                NULL, /* NULL - ssl_get_record */ \
 
651
                NULL, /* NULL - ssl_write_bytes */ \
 
652
                NULL, /* NULL - dispatch_alert */ \
 
653
                ssl2_ctrl,      /* local */ \
 
654
                ssl2_ctx_ctrl,  /* local */ \
 
655
                ssl2_get_cipher_by_char, \
 
656
                ssl2_put_cipher_by_char, \
 
657
                ssl2_pending, \
 
658
                ssl2_num_ciphers, \
 
659
                ssl2_get_cipher, \
 
660
                s_get_meth, \
 
661
                ssl2_default_timeout, \
 
662
                &ssl3_undef_enc_method, \
 
663
                ssl_undefined_void_function, \
 
664
                ssl2_callback_ctrl,     /* local */ \
 
665
                ssl2_ctx_callback_ctrl, /* local */ \
 
666
        }; \
 
667
        return &func_name##_data; \
 
668
        }
 
669
 
 
670
#define IMPLEMENT_dtls1_meth_func(func_name, s_accept, s_connect, s_get_meth) \
 
671
SSL_METHOD *func_name(void)  \
 
672
        { \
 
673
        static SSL_METHOD func_name##_data= { \
 
674
                DTLS1_VERSION, \
 
675
                dtls1_new, \
 
676
                dtls1_clear, \
 
677
                dtls1_free, \
 
678
                s_accept, \
 
679
                s_connect, \
 
680
                ssl3_read, \
 
681
                ssl3_peek, \
 
682
                ssl3_write, \
 
683
                ssl3_shutdown, \
 
684
                ssl3_renegotiate, \
 
685
                ssl3_renegotiate_check, \
 
686
                dtls1_get_message, \
 
687
                dtls1_read_bytes, \
 
688
                dtls1_write_app_data_bytes, \
 
689
                dtls1_dispatch_alert, \
 
690
                ssl3_ctrl, \
 
691
                ssl3_ctx_ctrl, \
 
692
                ssl3_get_cipher_by_char, \
 
693
                ssl3_put_cipher_by_char, \
 
694
                ssl3_pending, \
 
695
                ssl3_num_ciphers, \
 
696
                ssl3_get_cipher, \
 
697
                s_get_meth, \
 
698
                dtls1_default_timeout, \
 
699
                &DTLSv1_enc_data, \
 
700
                ssl_undefined_void_function, \
 
701
                ssl3_callback_ctrl, \
 
702
                ssl3_ctx_callback_ctrl, \
 
703
        }; \
 
704
        return &func_name##_data; \
 
705
        }
 
706
 
480
707
void ssl_clear_cipher_ctx(SSL *s);
481
708
int ssl_clear_bad_session(SSL *s);
482
709
CERT *ssl_cert_new(void);
493
720
                        const SSL_CIPHER * const *bp);
494
721
STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,
495
722
                                               STACK_OF(SSL_CIPHER) **skp);
496
 
int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p);
 
723
int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p,
 
724
                             int (*put_cb)(const SSL_CIPHER *, unsigned char *));
497
725
STACK_OF(SSL_CIPHER) *ssl_create_cipher_list(const SSL_METHOD *meth,
498
726
                                             STACK_OF(SSL_CIPHER) **pref,
499
727
                                             STACK_OF(SSL_CIPHER) **sorted,
500
728
                                             const char *rule_str);
501
729
void ssl_update_cache(SSL *s, int mode);
502
 
int ssl_cipher_get_evp(SSL_SESSION *s,const EVP_CIPHER **enc,const EVP_MD **md,
503
 
                       SSL_COMP **comp);
 
730
int ssl_cipher_get_evp(const SSL_SESSION *s,const EVP_CIPHER **enc,
 
731
                       const EVP_MD **md,SSL_COMP **comp);
504
732
int ssl_verify_cert_chain(SSL *s,STACK_OF(X509) *sk);
505
733
int ssl_undefined_function(SSL *s);
 
734
int ssl_undefined_void_function(void);
 
735
int ssl_undefined_const_function(const SSL *s);
506
736
X509 *ssl_get_server_send_cert(SSL *);
507
737
EVP_PKEY *ssl_get_sign_pkey(SSL *,SSL_CIPHER *);
508
738
int ssl_cert_type(X509 *x,EVP_PKEY *pkey);
509
739
void ssl_set_cert_masks(CERT *c, SSL_CIPHER *cipher);
510
740
STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s);
511
741
int ssl_verify_alarm_type(long type);
 
742
void ssl_load_ciphers(void);
512
743
 
513
744
int ssl2_enc_init(SSL *s, int client);
514
745
int ssl2_generate_key_material(SSL *s);
518
749
int ssl2_put_cipher_by_char(const SSL_CIPHER *c,unsigned char *p);
519
750
int ssl2_part_read(SSL *s, unsigned long f, int i);
520
751
int ssl2_do_write(SSL *s);
521
 
int ssl2_set_certificate(SSL *s, int type, int len, unsigned char *data);
 
752
int ssl2_set_certificate(SSL *s, int type, int len, const unsigned char *data);
522
753
void ssl2_return_error(SSL *s,int reason);
523
754
void ssl2_write_error(SSL *s);
524
755
int ssl2_num_ciphers(void);
534
765
void    ssl2_clear(SSL *s);
535
766
long    ssl2_ctrl(SSL *s,int cmd, long larg, void *parg);
536
767
long    ssl2_ctx_ctrl(SSL_CTX *s,int cmd, long larg, void *parg);
537
 
long    ssl2_callback_ctrl(SSL *s,int cmd, void (*fp)());
538
 
long    ssl2_ctx_callback_ctrl(SSL_CTX *s,int cmd, void (*fp)());
539
 
int     ssl2_pending(SSL *s);
 
768
long    ssl2_callback_ctrl(SSL *s,int cmd, void (*fp)(void));
 
769
long    ssl2_ctx_callback_ctrl(SSL_CTX *s,int cmd, void (*fp)(void));
 
770
int     ssl2_pending(const SSL *s);
 
771
long    ssl2_default_timeout(void );
540
772
 
541
773
SSL_CIPHER *ssl3_get_cipher_by_char(const unsigned char *p);
542
774
int ssl3_put_cipher_by_char(const SSL_CIPHER *c,unsigned char *p);
582
814
void    ssl3_clear(SSL *s);
583
815
long    ssl3_ctrl(SSL *s,int cmd, long larg, void *parg);
584
816
long    ssl3_ctx_ctrl(SSL_CTX *s,int cmd, long larg, void *parg);
585
 
long    ssl3_callback_ctrl(SSL *s,int cmd, void (*fp)());
586
 
long    ssl3_ctx_callback_ctrl(SSL_CTX *s,int cmd, void (*fp)());
587
 
int     ssl3_pending(SSL *s);
 
817
long    ssl3_callback_ctrl(SSL *s,int cmd, void (*fp)(void));
 
818
long    ssl3_ctx_callback_ctrl(SSL_CTX *s,int cmd, void (*fp)(void));
 
819
int     ssl3_pending(const SSL *s);
 
820
 
 
821
void ssl3_record_sequence_update(unsigned char *seq);
 
822
int ssl3_do_change_cipher_spec(SSL *ssl);
 
823
long ssl3_default_timeout(void );
 
824
 
 
825
int ssl23_num_ciphers(void );
 
826
SSL_CIPHER *ssl23_get_cipher(unsigned int u);
 
827
int ssl23_read(SSL *s, void *buf, int len);
 
828
int ssl23_peek(SSL *s, void *buf, int len);
 
829
int ssl23_write(SSL *s, const void *buf, int len);
 
830
int ssl23_put_cipher_by_char(const SSL_CIPHER *c, unsigned char *p);
 
831
SSL_CIPHER *ssl23_get_cipher_by_char(const unsigned char *p);
 
832
long ssl23_default_timeout(void );
 
833
 
 
834
long tls1_default_timeout(void);
 
835
int dtls1_do_write(SSL *s,int type);
 
836
int ssl3_read_n(SSL *s, int n, int max, int extend);
 
837
int dtls1_read_bytes(SSL *s, int type, unsigned char *buf, int len, int peek);
 
838
int ssl3_do_compress(SSL *ssl);
 
839
int ssl3_do_uncompress(SSL *ssl);
 
840
int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
 
841
        unsigned int len);
 
842
unsigned char *dtls1_set_message_header(SSL *s, 
 
843
        unsigned char *p, unsigned char mt,     unsigned long len, 
 
844
        unsigned long frag_off, unsigned long frag_len);
 
845
 
 
846
int dtls1_write_app_data_bytes(SSL *s, int type, const void *buf, int len);
 
847
int dtls1_write_bytes(SSL *s, int type, const void *buf, int len);
 
848
 
 
849
int dtls1_send_change_cipher_spec(SSL *s, int a, int b);
 
850
int dtls1_send_finished(SSL *s, int a, int b, const char *sender, int slen);
 
851
unsigned long dtls1_output_cert_chain(SSL *s, X509 *x);
 
852
int dtls1_read_failed(SSL *s, int code);
 
853
int dtls1_buffer_message(SSL *s, int ccs);
 
854
int dtls1_retransmit_message(SSL *s, unsigned short seq, 
 
855
        unsigned long frag_off, int *found);
 
856
void dtls1_clear_record_buffer(SSL *s);
 
857
void dtls1_get_message_header(unsigned char *data, struct hm_header_st *msg_hdr);
 
858
void dtls1_get_ccs_header(unsigned char *data, struct ccs_header_st *ccs_hdr);
 
859
void dtls1_reset_seq_numbers(SSL *s, int rw);
 
860
long dtls1_default_timeout(void);
 
861
 
 
862
 
 
863
/* some client-only functions */
 
864
int ssl3_client_hello(SSL *s);
 
865
int ssl3_get_server_hello(SSL *s);
 
866
int ssl3_get_certificate_request(SSL *s);
 
867
int ssl3_get_server_done(SSL *s);
 
868
int ssl3_send_client_verify(SSL *s);
 
869
int ssl3_send_client_certificate(SSL *s);
 
870
int ssl3_send_client_key_exchange(SSL *s);
 
871
int ssl3_get_key_exchange(SSL *s);
 
872
int ssl3_get_server_certificate(SSL *s);
 
873
int ssl3_check_cert_and_algorithm(SSL *s);
 
874
 
 
875
int dtls1_client_hello(SSL *s);
 
876
int dtls1_send_client_certificate(SSL *s);
 
877
int dtls1_send_client_key_exchange(SSL *s);
 
878
int dtls1_send_client_verify(SSL *s);
 
879
 
 
880
/* some server-only functions */
 
881
int ssl3_get_client_hello(SSL *s);
 
882
int ssl3_send_server_hello(SSL *s);
 
883
int ssl3_send_hello_request(SSL *s);
 
884
int ssl3_send_server_key_exchange(SSL *s);
 
885
int ssl3_send_certificate_request(SSL *s);
 
886
int ssl3_send_server_done(SSL *s);
 
887
int ssl3_check_client_hello(SSL *s);
 
888
int ssl3_get_client_certificate(SSL *s);
 
889
int ssl3_get_client_key_exchange(SSL *s);
 
890
int ssl3_get_cert_verify(SSL *s);
 
891
 
 
892
int dtls1_send_hello_request(SSL *s);
 
893
int dtls1_send_server_hello(SSL *s);
 
894
int dtls1_send_server_certificate(SSL *s);
 
895
int dtls1_send_server_key_exchange(SSL *s);
 
896
int dtls1_send_certificate_request(SSL *s);
 
897
int dtls1_send_server_done(SSL *s);
 
898
 
 
899
 
588
900
 
589
901
int ssl23_accept(SSL *s);
590
902
int ssl23_connect(SSL *s);
595
907
void tls1_free(SSL *s);
596
908
void tls1_clear(SSL *s);
597
909
long tls1_ctrl(SSL *s,int cmd, long larg, void *parg);
598
 
long tls1_callback_ctrl(SSL *s,int cmd, void (*fp)());
 
910
long tls1_callback_ctrl(SSL *s,int cmd, void (*fp)(void));
599
911
SSL_METHOD *tlsv1_base_method(void );
600
912
 
 
913
int dtls1_new(SSL *s);
 
914
int     dtls1_accept(SSL *s);
 
915
int     dtls1_connect(SSL *s);
 
916
void dtls1_free(SSL *s);
 
917
void dtls1_clear(SSL *s);
 
918
long dtls1_ctrl(SSL *s,int cmd, long larg, void *parg);
 
919
SSL_METHOD *dtlsv1_base_method(void );
 
920
 
 
921
long dtls1_get_message(SSL *s, int st1, int stn, int mt, long max, int *ok);
 
922
int dtls1_get_record(SSL *s);
 
923
int do_dtls1_write(SSL *s, int type, const unsigned char *buf,
 
924
        unsigned int len, int create_empty_fragement);
 
925
int dtls1_dispatch_alert(SSL *s);
 
926
int dtls1_enc(SSL *s, int snd);
 
927
 
601
928
int ssl_init_wbio_buffer(SSL *s, int push);
602
929
void ssl_free_wbio_buffer(SSL *s);
603
930
 
614
941
int ssl3_alert_code(int code);
615
942
int ssl_ok(SSL *s);
616
943
 
 
944
int check_srvr_ecc_cert_and_alg(X509 *x, SSL_CIPHER *cs);
 
945
 
617
946
SSL_COMP *ssl3_comp_find(STACK_OF(SSL_COMP) *sk, int n);
618
 
STACK_OF(SSL_COMP) *SSL_COMP_get_compression_methods(void);
619
947
 
620
948
 
621
949
#endif