Penguin
Recent Changes
Annotated edit history of ssl(3) version 2 showing authors affecting page license. View with all changes included.
Rev Author # Line
1 perry 1 ssl
2 !!!ssl
3 NAME
4 SYNOPSIS
5 DESCRIPTION
6 DATA STRUCTURES
7 HEADER FILES
8 API FUNCTIONS
9 SEE ALSO
10 HISTORY
11 ----
12 !!NAME
13
14
15 SSL - OpenSSL SSL/TLS library
16 !!SYNOPSIS
17 !!DESCRIPTION
18
19
20 The OpenSSL __ssl__ library implements the Secure
21 Sockets Layer ( SSL v2/v3) and Transport Layer
22 Security ( TLS v1) protocols. It provides a
23 rich API which is documented
24 here.
25
26
27 At first the library must be initialized; see
28 ''SSL_library_init''(3).
29
30
31 Then an __SSL_CTX__ object is created as
32 a framework to establish TLS/SSL enabled
33 connections (see ''SSL_CTX_new''(3)). Various options
34 regarding certificates, algorithms etc. can be set in this
35 object.
36
37
38 When a network connection has been created, it can be
39 assigned to an __SSL__ object. After the
40 __SSL__ object has been created using
41 ''SSL_new''(3), ''SSL_set_fd''(3) or
42 ''SSL_set_bio''(3) can be used to associate the network
43 connection with the object.
44
45
46 Then the TLS/SSL handshake is performed
47 using ''SSL_accept''(3) or ''SSL_connect''(3)
48 respectively. ''SSL_read''(3) and ''SSL_write''(3) are
49 used to read and write data on the TLS/SSL
50 connection. ''SSL_shutdown''(3) can be used to shut
51 down the TLS/SSL connection.
52 !!DATA STRUCTURES
53
54
55 Currently the OpenSSL __ssl__ library functions
56 deals with the following data structures:
57
58
59 __SSL_METHOD__ ( SSL
60 Method)
61
62
63 That's a dispatch structure describing the internal
64 __ssl__ library methods/functions which implement the
65 various protocol versions (SSLv1, SSLv2 and TLSv1). It's
66 needed to create an __SSL_CTX__
67 .
68
69
70 __SSL_CIPHER__ ( SSL
71 Cipher)
72
73
74 This structure holds the algorithm information for a
75 particular cipher which are a core part of the SSL/TLS
76 protocol. The available ciphers are configured on
77 a __SSL_CTX__ basis and the actually used ones
78 are then part of the __SSL_SESSION__
79 .
80
81
82 __SSL_CTX__ ( SSL
83 Context)
84
85
86 That's the global context structure which is created by
87 a server or client once per program life-time and which
88 holds mainly default values for the __SSL__
89 structures which are later created for the
90 connections.
91
92
93 __SSL_SESSION__ ( SSL
94 Session)
95
96
97 This is a structure containing the current
98 TLS/SSL session details for a connection:
99 __SSL_CIPHER__ s, client and server certificates,
100 keys, etc.
101
102
103 __SSL__ ( SSL
104 Connection)
105
106
107 That's the main SSL/TLS structure which is
108 created by a server or client per established connection.
109 This actually is the core structure in the SSL API
110 . Under run-time the application usually deals with
111 this structure which has links to mostly all other
112 structures.
113 !!HEADER FILES
114
115
116 Currently the OpenSSL __ssl__ library provides the
117 following C header files containing the prototypes for the
118 data structures and and functions:
119
120
121 __ssl.h__
122
123
124 That's the common header file for the SSL/TLS API
125 . Include it into your program to make the API
126 of the __ssl__ library available. It internally
127 includes both more private SSL headers and
128 headers from the __crypto__ library. Whenever you need
129 hard-core details on the internals of the SSL API
130 , look inside this header file.
131
132
133 __ssl2.h__
134
135
136 That's the sub header file dealing with the SSLv2
137 protocol only. ''Usually you don't have to include it
138 explicitly because it's already included by
139 ssl.h''.
140
141
142 __ssl3.h__
143
144
145 That's the sub header file dealing with the SSLv3
146 protocol only. ''Usually you don't have to include it
147 explicitly because it's already included by
148 ssl.h''.
149
150
151 __ssl23.h__
152
153
154 That's the sub header file dealing with the combined
155 use of the SSLv2 and SSLv3 protocols. ''Usually you don't
156 have to include it explicitly because it's already included
157 by ssl.h''.
158
159
160 __tls1.h__
161
162
163 That's the sub header file dealing with the TLSv1
164 protocol only. ''Usually you don't have to include it
165 explicitly because it's already included by
166 ssl.h''.
167 !!API FUNCTIONS
168
169
170 Currently the OpenSSL __ssl__ library exports
171 214 API functions. They are documented in the
172 following:
173
174
175 __DEALING WITH PROTOCOL METHODS__
176
177
178 Here we document the various API functions
179 which deal with the SSL/TLS protocol methods
180 defined in __SSL_METHOD__
181 structures.
182
183
184 SSL_METHOD
185 *__SSLv2_client_method__(void);
186
187
188 Constructor for the SSLv2 SSL_METHOD
189 structure for a dedicated client.
190
191
192 SSL_METHOD
193 *__SSLv2_server_method__(void);
194
195
196 Constructor for the SSLv2 SSL_METHOD
197 structure for a dedicated server.
198
199
200 SSL_METHOD
201 *__SSLv2_method__(void);
202
203
204 Constructor for the SSLv2 SSL_METHOD
205 structure for combined client and
206 server.
207
208
209 SSL_METHOD
210 *__SSLv3_client_method__(void);
211
212
213 Constructor for the SSLv3 SSL_METHOD
214 structure for a dedicated client.
215
216
217 SSL_METHOD
218 *__SSLv3_server_method__(void);
219
220
221 Constructor for the SSLv3 SSL_METHOD
222 structure for a dedicated server.
223
224
225 SSL_METHOD
226 *__SSLv3_method__(void);
227
228
229 Constructor for the SSLv3 SSL_METHOD
230 structure for combined client and
231 server.
232
233
234 SSL_METHOD
235 *__TLSv1_client_method__(void);
236
237
238 Constructor for the TLSv1 SSL_METHOD
239 structure for a dedicated client.
240
241
242 SSL_METHOD
243 *__TLSv1_server_method__(void);
244
245
246 Constructor for the TLSv1 SSL_METHOD
247 structure for a dedicated server.
248
249
250 SSL_METHOD
251 *__TLSv1_method__(void);
252
253
254 Constructor for the TLSv1 SSL_METHOD
255 structure for combined client and
256 server.
257
258
259 __DEALING WITH CIPHERS__
260
261
262 Here we document the various API functions
263 which deal with the SSL/TLS ciphers defined
264 in __SSL_CIPHER__
265 structures.
266
267
268 char *__SSL_CIPHER_description__( SSL_CIPHER
269 *cipher, char *buf, int len);
270
271
272 Write a string to ''buf'' (with a maximum size of
273 ''len'') containing a human readable description of
274 ''cipher''. Returns ''buf''.
275
276
277 int __SSL_CIPHER_get_bits__( SSL_CIPHER
278 *cipher, int *alg_bits);
279
280
281 Determine the number of bits in ''cipher''. Because
282 of export crippled ciphers there are two bits: The bits the
283 algorithm supports in general (stored to ''alg_bits'')
284 and the bits which are actually used (the return
285 value).
286
287
288 const char *__SSL_CIPHER_get_name__(
289 SSL_CIPHER *cipher);
290
291
292 Return the internal name of ''cipher'' as a string.
293 These are the various strings defined by the
294 ''SSL2_TXT_xxx'', ''SSL3_TXT_xxx'' and
295 ''TLS1_TXT_xxx'' definitions in the header
296 files.
297
298
299 char *__SSL_CIPHER_get_version__( SSL_CIPHER
300 *cipher);
301
302
303 Returns a string like TLSv1/SSLv3`` or
304 ''SSLv2 SSL/TLS
305 protocol version to which ''cipher'' belongs (i.e.
306 where it was defined in the specification the first
307 time).
308
309
310 __DEALING WITH PROTOCOL CONTEXTS__
311
312
313 Here we document the various API functions
314 which deal with the SSL/TLS protocol context
315 defined in the __SSL_CTX__
316 structure.
317
318
319 int __SSL_CTX_add_client_CA__( SSL_CTX
320 *ctx, X509 *x);
321
322
323 long __SSL_CTX_add_extra_chain_cert__( SSL_CTX
324 *ctx, X509 *x509);
325
326
327 int __SSL_CTX_add_session__( SSL_CTX
328 *ctx, SSL_SESSION *c);
329
330
331 int __SSL_CTX_check_private_key__( SSL_CTX
332 *ctx);
333
334
335 long __SSL_CTX_ctrl__( SSL_CTX *ctx, int
336 cmd, long larg, char *parg);
337
338
339 void __SSL_CTX_flush_sessions__( SSL_CTX
340 *s, long t);
341
342
343 void __SSL_CTX_free__( SSL_CTX
344 *a);
345
346
347 char *__SSL_CTX_get_app_data__( SSL_CTX
348 *ctx);
349
350
351 X509_STORE *__SSL_CTX_get_cert_store__(
352 SSL_CTX *ctx);
353
354
355 STACK *__SSL_CTX_get_client_CA_list__( SSL_CTX
356 *ctx);
357
358
359 int (*__SSL_CTX_get_client_cert_cb__( SSL_CTX
360 *ctx))( SSL *ssl, X509 **x509,
361 EVP_PKEY **pkey);
362
363
364 char *__SSL_CTX_get_ex_data__( SSL_CTX
365 *s, int idx);
366
367
368 int __SSL_CTX_get_ex_new_index__(long argl, char
369 *argp, int (*new_func);(void), int (*dup_func)(void), void
370 (*free_func)(void))
371
372
373 void (*__SSL_CTX_get_info_callback__( SSL_CTX
374 *ctx))( SSL *ssl, int cb, int
375 ret);
376
377
378 int __SSL_CTX_get_quiet_shutdown__( SSL_CTX
379 *ctx);
380
381
382 int __SSL_CTX_get_session_cache_mode__(
383 SSL_CTX *ctx);
384
385
386 long __SSL_CTX_get_timeout__( SSL_CTX
387 *ctx);
388
389
390 int (*__SSL_CTX_get_verify_callback__( SSL_CTX
391 *ctx))(int ok, X509_STORE_CTX *ctx);
392
393
394 int __SSL_CTX_get_verify_mode__( SSL_CTX
395 *ctx);
396
397
398 int __SSL_CTX_load_verify_locations__( SSL_CTX
399 *ctx, char *CAfile, char *CApath);
400
401
402 long __SSL_CTX_need_tmp_RSA__( SSL_CTX
403 *ctx);
404
405
406 SSL_CTX *__SSL_CTX_new__( SSL_METHOD
407 *meth);
408
409
410 int __SSL_CTX_remove_session__( SSL_CTX
411 *ctx, SSL_SESSION *c);
412
413
414 int __SSL_CTX_sess_accept__( SSL_CTX
415 *ctx);
416
417
418 int __SSL_CTX_sess_accept_good__( SSL_CTX
419 *ctx);
420
421
422 int __SSL_CTX_sess_accept_renegotiate__(
423 SSL_CTX *ctx);
424
425
426 int __SSL_CTX_sess_cache_full__( SSL_CTX
427 *ctx);
428
429
430 int __SSL_CTX_sess_cb_hits__( SSL_CTX
431 *ctx);
432
433
434 int __SSL_CTX_sess_connect__( SSL_CTX
435 *ctx);
436
437
438 int __SSL_CTX_sess_connect_good__( SSL_CTX
439 *ctx);
440
441
442 int __SSL_CTX_sess_connect_renegotiate__(
443 SSL_CTX *ctx);
444
445
446 int __SSL_CTX_sess_get_cache_size__( SSL_CTX
447 *ctx);
448
449
450 SSL_SESSION *(*__SSL_CTX_sess_get_get_cb__(
451 SSL_CTX *ctx))( SSL *ssl, unsigned char
452 *data, int len, int *copy);
453
454
455 int (*__SSL_CTX_sess_get_new_cb__( SSL_CTX
456 *ctx)( SSL *ssl, SSL_SESSION
457 *sess);
458
459
460 void (*__SSL_CTX_sess_get_remove_cb__( SSL_CTX
461 *ctx)( SSL_CTX *ctx, SSL_SESSION
462 *sess);
463
464
465 int __SSL_CTX_sess_hits__( SSL_CTX
466 *ctx);
467
468
469 int __SSL_CTX_sess_misses__( SSL_CTX
470 *ctx);
471
472
473 int __SSL_CTX_sess_number__( SSL_CTX
474 *ctx);
475
476
477 void __SSL_CTX_sess_set_cache_size__( SSL_CTX
478 *ctx,t);
479
480
481 void __SSL_CTX_sess_set_get_cb__( SSL_CTX
482 *ctx, SSL_SESSION *(*cb)( SSL
483 *ssl, unsigned char *data, int len, int
484 *copy));
485
486
487 void __SSL_CTX_sess_set_new_cb__( SSL_CTX
488 *ctx, int (*cb)( SSL *ssl, SSL_SESSION
489 *sess));
490
491
492 void __SSL_CTX_sess_set_remove_cb__( SSL_CTX
493 *ctx, void (*cb)( SSL_CTX *ctx,
494 SSL_SESSION *sess));
495
496
497 int __SSL_CTX_sess_timeouts__( SSL_CTX
498 *ctx);
499
500
501 LHASH *__SSL_CTX_sessions__( SSL_CTX
502 *ctx);
503
504
505 void __SSL_CTX_set_app_data__( SSL_CTX
506 *ctx, void *arg);
507
508
509 void __SSL_CTX_set_cert_store__( SSL_CTX
510 *ctx, X509_STORE *cs);
511
512
513 void __SSL_CTX_set_cert_verify_cb__( SSL_CTX
514 *ctx, int (*cb)(), char *arg)
515
516
517 int __SSL_CTX_set_cipher_list__( SSL_CTX
518 *ctx, char *str);
519
520
521 void __SSL_CTX_set_client_CA_list__( SSL_CTX
522 *ctx, STACK *list);
523
524
525 void __SSL_CTX_set_client_cert_cb__( SSL_CTX
526 *ctx, int (*cb)( SSL *ssl, X509
527 **x509, EVP_PKEY **pkey));
528
529
530 void __SSL_CTX_set_default_passwd_cb__(
531 SSL_CTX *ctx, int (*cb);(void))
532
533
534 void __SSL_CTX_set_default_read_ahead__(
535 SSL_CTX *ctx, int m);
536
537
538 int __SSL_CTX_set_default_verify_paths__(
539 SSL_CTX *ctx);
540
541
542 int __SSL_CTX_set_ex_data__( SSL_CTX *s,
543 int idx, char *arg);
544
545
546 void __SSL_CTX_set_info_callback__( SSL_CTX
547 *ctx, void (*cb)( SSL *ssl, int cb, int
548 ret));
549
550
551 void __SSL_CTX_set_options__( SSL_CTX
552 *ctx, unsigned long op);
553
554
555 void __SSL_CTX_set_quiet_shutdown__( SSL_CTX
556 *ctx, int mode);
557
558
559 void __SSL_CTX_set_session_cache_mode__(
560 SSL_CTX *ctx, int mode);
561
562
563 int __SSL_CTX_set_ssl_version__( SSL_CTX
564 *ctx, SSL_METHOD *meth);
565
566
567 void __SSL_CTX_set_timeout__( SSL_CTX
568 *ctx, long t);
569
570
571 long __SSL_CTX_set_tmp_dh__(SSL_CTX* ctx, DH
572 *dh);
573
574
575 long __SSL_CTX_set_tmp_dh_callback__( SSL_CTX
576 *ctx, DH *(*cb)(void));
577
578
579 long __SSL_CTX_set_tmp_rsa__( SSL_CTX
580 *ctx, RSA *rsa);
581
582
583 SSL_CTX_set_tmp_rsa_callback
584
585
586 long SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx, RSA
587 *(*cb)(SSL *ssl, int export, int
588 keylength));
589
590
591 Sets the callback which will be called when a temporary
592 private key is required. The __export__ flag will be set
593 if the reason for needing a temp key is that an export
594 ciphersuite is in use, in which case, __keylength__ will
595 contain the required keylength in bits. Generate a key of
596 appropriate size (using ???) and return
597 it.
598
599
600 SSL_set_tmp_rsa_callback
601
602
603 long __SSL_set_tmp_rsa_callback__( SSL
604 *ssl, RSA *(*cb)( SSL *ssl, int
605 export, int keylength));
606
607
608 The same as ``SSL_CTX_set_tmp_rsa_callback'', except it
609 operates on an SSL session instead of a
610 context.
611
612
613 void __SSL_CTX_set_verify__( SSL_CTX
614 *ctx, int mode, int (*cb);(void))
615
616
617 int __SSL_CTX_use_!PrivateKey__( SSL_CTX
618 *ctx, EVP_PKEY *pkey);
619
620
621 int __SSL_CTX_use_!PrivateKey_ASN1__(int type,
622 SSL_CTX *ctx, unsigned char *d, long
623 len);
624
625
626 int __SSL_CTX_use_!PrivateKey_file__( SSL_CTX
627 *ctx, char *file, int type);
628
629
630 int __SSL_CTX_use_RSAPrivateKey__( SSL_CTX
631 *ctx, RSA *rsa);
632
633
634 int __SSL_CTX_use_RSAPrivateKey_ASN1__(
635 SSL_CTX *ctx, unsigned char *d, long
636 len);
637
638
639 int __SSL_CTX_use_RSAPrivateKey_file__(
640 SSL_CTX *ctx, char *file, int type);
641
642
643 int __SSL_CTX_use_certificate__( SSL_CTX
644 *ctx, X509 *x);
645
646
647 int __SSL_CTX_use_certificate_ASN1__( SSL_CTX
648 *ctx, int len, unsigned char *d);
649
650
651 int __SSL_CTX_use_certificate_file__( SSL_CTX
652 *ctx, char *file, int type);
653
654
655 __DEALING WITH SESSIONS__
656
657
658 Here we document the various API functions
659 which deal with the SSL/TLS sessions defined in
660 the __SSL_SESSION__
661 structures.
662
663
664 int __SSL_SESSION_cmp__( SSL_SESSION
665 *a, SSL_SESSION *b);
666
667
668 void __SSL_SESSION_free__( SSL_SESSION
669 *ss);
670
671
672 char *__SSL_SESSION_get_app_data__(
673 SSL_SESSION *s);
674
675
676 char *__SSL_SESSION_get_ex_data__( SSL_SESSION
677 *s, int idx);
678
679
680 int __SSL_SESSION_get_ex_new_index__(long argl, char
681 *argp, int (*new_func);(void), int (*dup_func)(void), void
682 (*free_func)(void))
683
684
685 long __SSL_SESSION_get_time__( SSL_SESSION
686 *s);
687
688
689 long __SSL_SESSION_get_timeout__( SSL_SESSION
690 *s);
691
692
693 unsigned long __SSL_SESSION_hash__(
694 SSL_SESSION *a);
695
696
697 SSL_SESSION
698 *__SSL_SESSION_new__(void);
699
700
701 int __SSL_SESSION_print__( BIO *bp,
702 SSL_SESSION *x);
703
704
705 int __SSL_SESSION_print_fp__( FILE
706 *fp, SSL_SESSION *x);
707
708
709 void __SSL_SESSION_set_app_data__( SSL_SESSION
710 *s, char *a);
711
712
713 int __SSL_SESSION_set_ex_data__( SSL_SESSION
714 *s, int idx, char *arg);
715
716
717 long __SSL_SESSION_set_time__( SSL_SESSION
718 *s, long t);
719
720
721 long __SSL_SESSION_set_timeout__( SSL_SESSION
722 *s, long t);
723
724
725 __DEALING WITH CONNECTIONS__
726
727
728 Here we document the various API functions
729 which deal with the SSL/TLS connection defined in
730 the __SSL__ structure.
731
732
733 int __SSL_accept__( SSL
734 *ssl);
735
736
737 int __SSL_add_dir_cert_subjects_to_stack__(
738 STACK *stack, const char *dir);
739
740
741 int __SSL_add_file_cert_subjects_to_stack__(
742 STACK *stack, const char *file);
743
744
745 int __SSL_add_client_CA__( SSL *ssl, X509
746 *x);
747
748
749 char *__SSL_alert_desc_string__(int
750 value);
751
752
753 char *__SSL_alert_desc_string_long__(int
754 value);
755
756
757 char *__SSL_alert_type_string__(int
758 value);
759
760
761 char *__SSL_alert_type_string_long__(int
762 value);
763
764
765 int __SSL_check_private_key__( SSL
766 *ssl);
767
768
769 void __SSL_clear__( SSL
770 *ssl);
771
772
773 long __SSL_clear_num_renegotiations__( SSL
774 *ssl);
775
776
777 int __SSL_connect__( SSL
778 *ssl);
779
780
781 void __SSL_copy_session_id__( SSL
782 *t, SSL *f);
783
784
785 long __SSL_ctrl__( SSL *ssl, int cmd,
786 long larg, char *parg);
787
788
789 int __SSL_do_handshake__( SSL
790 *ssl);
791
792
793 SSL *__SSL_dup__( SSL
794 *ssl);
795
796
797 STACK *__SSL_dup_CA_list__( STACK
798 *sk);
799
800
801 void __SSL_free__( SSL
802 *ssl);
803
804
805 SSL_CTX *__SSL_get_SSL_CTX__( SSL
806 *ssl);
807
808
809 char *__SSL_get_app_data__( SSL
810 *ssl);
811
812
813 X509 *__SSL_get_certificate__( SSL
814 *ssl);
815
816
817 const char *__SSL_get_cipher__( SSL
818 *ssl);
819
820
821 int __SSL_get_cipher_bits__( SSL *ssl,
822 int *alg_bits);
823
824
825 char *__SSL_get_cipher_list__( SSL *ssl,
826 int n);
827
828
829 char *__SSL_get_cipher_name__( SSL
830 *ssl);
831
832
833 char *__SSL_get_cipher_version__( SSL
834 *ssl);
835
836
837 STACK *__SSL_get_ciphers__( SSL
838 *ssl);
839
840
841 STACK *__SSL_get_client_CA_list__( SSL
842 *ssl);
843
844
845 SSL_CIPHER *__SSL_get_current_cipher__( SSL
846 *ssl);
847
848
849 long __SSL_get_default_timeout__( SSL
850 *ssl);
851
852
853 int __SSL_get_error__( SSL *ssl, int
854 i);
855
856
857 char *__SSL_get_ex_data__( SSL *ssl, int
858 idx);
859
860
861 int
862 __SSL_get_ex_data_X509_STORE_CTX_idx__(void);
863
864
865 int __SSL_get_ex_new_index__(long argl, char *argp,
866 int (*new_func);(void), int (*dup_func)(void), void
867 (*free_func)(void))
868
869
870 int __SSL_get_fd__( SSL
871 *ssl);
872
873
874 void (*__SSL_get_info_callback__( SSL
875 *ssl);)(void)
876
877
878 STACK *__SSL_get_peer_cert_chain__( SSL
879 *ssl);
880
881
882 X509 *__SSL_get_peer_certificate__( SSL
883 *ssl);
884
885
886 EVP_PKEY *__SSL_get_privatekey__( SSL
887 *ssl);
888
889
890 int __SSL_get_quiet_shutdown__( SSL
891 *ssl);
892
893
894 BIO *__SSL_get_rbio__( SSL
895 *ssl);
896
897
898 int __SSL_get_read_ahead__( SSL
899 *ssl);
900
901
902 SSL_SESSION *__SSL_get_session__( SSL
903 *ssl);
904
905
906 char *__SSL_get_shared_ciphers__( SSL
907 *ssl, char *buf, int len);
908
909
910 int __SSL_get_shutdown__( SSL
911 *ssl);
912
913
914 SSL_METHOD *__SSL_get_ssl_method__( SSL
915 *ssl);
916
917
918 int __SSL_get_state__( SSL
919 *ssl);
920
921
922 long __SSL_get_time__( SSL
923 *ssl);
924
925
926 long __SSL_get_timeout__( SSL
927 *ssl);
928
929
930 int (*__SSL_get_verify_callback__( SSL
931 *ssl);)(void)
932
933
934 int __SSL_get_verify_mode__( SSL
935 *ssl);
936
937
938 long __SSL_get_verify_result__( SSL
939 *ssl);
940
941
942 char *__SSL_get_version__( SSL
943 *ssl);
944
945
946 BIO *__SSL_get_wbio__( SSL
947 *ssl);
948
949
950 int __SSL_in_accept_init__( SSL
951 *ssl);
952
953
954 int __SSL_in_before__( SSL
955 *ssl);
956
957
958 int __SSL_in_connect_init__( SSL
959 *ssl);
960
961
962 int __SSL_in_init__( SSL
963 *ssl);
964
965
966 int __SSL_is_init_finished__( SSL
967 *ssl);
968
969
970 STACK *__SSL_load_client_CA_file__(char
971 *file);
972
973
974 void
975 __SSL_load_error_strings__(void);
976
977
978 SSL *__SSL_new__( SSL_CTX
979 *ctx);
980
981
982 long __SSL_num_renegotiations__( SSL
983 *ssl);
984
985
986 int __SSL_peek__( SSL *ssl, void *buf,
987 int num);
988
989
990 int __SSL_pending__( SSL
991 *ssl);
992
993
994 int __SSL_read__( SSL *ssl, void *buf,
995 int num);
996
997
998 int __SSL_renegotiate__( SSL
999 *ssl);
1000
1001
1002 char *__SSL_rstate_string__( SSL
1003 *ssl);
1004
1005
1006 char *__SSL_rstate_string_long__( SSL
1007 *ssl);
1008
1009
1010 long __SSL_session_reused__( SSL
1011 *ssl);
1012
1013
1014 void __SSL_set_accept_state__( SSL
1015 *ssl);
1016
1017
1018 void __SSL_set_app_data__( SSL *ssl, char
1019 *arg);
1020
1021
1022 void __SSL_set_bio__( SSL *ssl, BIO
1023 *rbio, BIO *wbio);
1024
1025
1026 int __SSL_set_cipher_list__( SSL *ssl,
1027 char *str);
1028
1029
1030 void __SSL_set_client_CA_list__( SSL
1031 *ssl, STACK *list);
1032
1033
1034 void __SSL_set_connect_state__( SSL
1035 *ssl);
1036
1037
1038 int __SSL_set_ex_data__( SSL *ssl, int
1039 idx, char *arg);
1040
1041
1042 int __SSL_set_fd__( SSL *ssl, int
1043 fd);
1044
1045
1046 void __SSL_set_info_callback__( SSL *ssl,
1047 void (*cb);(void))
1048
1049
1050 void __SSL_set_options__( SSL *ssl,
1051 unsigned long op);
1052
1053
1054 void __SSL_set_quiet_shutdown__( SSL
1055 *ssl, int mode);
1056
1057
1058 void __SSL_set_read_ahead__( SSL *ssl,
1059 int yes);
1060
1061
1062 int __SSL_set_rfd__( SSL *ssl, int
1063 fd);
1064
1065
1066 int __SSL_set_session__( SSL *ssl,
1067 SSL_SESSION *session);
1068
1069
1070 void __SSL_set_shutdown__( SSL *ssl, int
1071 mode);
1072
1073
1074 int __SSL_set_ssl_method__( SSL
1075 *ssl, SSL_METHOD *meth);
1076
1077
1078 void __SSL_set_time__( SSL *ssl, long
1079 t);
1080
1081
1082 void __SSL_set_timeout__( SSL *ssl, long
1083 t);
1084
1085
1086 void __SSL_set_verify__( SSL *ssl, int
1087 mode, int (*callback);(void))
1088
1089
1090 void __SSL_set_verify_result__( SSL *ssl,
1091 long arg);
1092
1093
1094 int __SSL_set_wfd__( SSL *ssl, int
1095 fd);
1096
1097
1098 int __SSL_shutdown__( SSL
1099 *ssl);
1100
1101
1102 int __SSL_state__( SSL
1103 *ssl);
1104
1105
1106 char *__SSL_state_string__( SSL
1107 *ssl);
1108
1109
1110 char *__SSL_state_string_long__( SSL
1111 *ssl);
1112
1113
1114 long __SSL_total_renegotiations__( SSL
1115 *ssl);
1116
1117
1118 int __SSL_use_!PrivateKey__( SSL
1119 *ssl, EVP_PKEY *pkey);
1120
1121
1122 int __SSL_use_!PrivateKey_ASN1__(int type, SSL
1123 *ssl, unsigned char *d, long len);
1124
1125
1126 int __SSL_use_!PrivateKey_file__( SSL
1127 *ssl, char *file, int type);
1128
1129
1130 int __SSL_use_RSAPrivateKey__( SSL
1131 *ssl, RSA *rsa);
1132
1133
1134 int __SSL_use_RSAPrivateKey_ASN1__( SSL
1135 *ssl, unsigned char *d, long len);
1136
1137
1138 int __SSL_use_RSAPrivateKey_file__( SSL
1139 *ssl, char *file, int type);
1140
1141
1142 int __SSL_use_certificate__( SSL *ssl,
1143 X509 *x);
1144
1145
1146 int __SSL_use_certificate_ASN1__( SSL
1147 *ssl, int len, unsigned char *d);
1148
1149
1150 int __SSL_use_certificate_file__( SSL
1151 *ssl, char *file, int type);
1152
1153
1154 int __SSL_version__( SSL
1155 *ssl);
1156
1157
1158 int __SSL_want__( SSL
1159 *ssl);
1160
1161
1162 int __SSL_want_nothing__( SSL
1163 *ssl);
1164
1165
1166 int __SSL_want_read__( SSL
1167 *ssl);
1168
1169
1170 int __SSL_want_write__( SSL
1171 *ssl);
1172
1173
1174 int __SSL_want_x509_lookup__(s);
1175
1176
1177 int __SSL_write__( SSL *ssl, const void
1178 *buf, int num);
1179 !!SEE ALSO
1180
1181
1182 openssl(1), crypto(3),
1183 ''SSL_accept''(3), ''SSL_clear''(3),
1184 ''SSL_connect''(3), ''SSL_CIPHER_get_name''(3),
1185 ''SSL_COMP_add_compression_method''(3),
1186 ''SSL_CTX_add_extra_chain_cert''(3),
1187 ''SSL_CTX_add_session''(3), ''SSL_CTX_ctrl''(3),
1188 ''SSL_CTX_flush_sessions''(3),
1189 ''SSL_CTX_get_ex_new_index''(3),
1190 ''SSL_CTX_get_verify_mode''(3),
1191 ''SSL_CTX_load_verify_locations''(3)
1192 ''SSL_CTX_new''(3), ''SSL_CTX_sess_number''(3),
1193 ''SSL_CTX_sess_set_cache_size''(3),
1194 ''SSL_CTX_sess_set_get_cb''(3),
1195 ''SSL_CTX_sessions''(3),
1196 ''SSL_CTX_set_cert_store''(3),
1197 ''SSL_CTX_set_cert_verify_callback''(3),
1198 ''SSL_CTX_set_cipher_list''(3),
1199 ''SSL_CTX_set_client_CA_list''(3),
1200 ''SSL_CTX_set_default_passwd_cb''(3),
1201 ''SSL_CTX_set_info_callback''(3),
1202 ''SSL_CTX_set_mode''(3), ''SSL_CTX_set_options''(3),
1203 ''SSL_CTX_set_quiet_shutdown''(3),
1204 ''SSL_CTX_set_session_cache_mode''(3),
1205 ''SSL_CTX_set_session_id_context''(3),
1206 ''SSL_CTX_set_ssl_version''(3),
1207 ''SSL_CTX_set_timeout''(3),
1208 ''SSL_CTX_set_tmp_rsa_callback''(3),
1209 ''SSL_CTX_set_tmp_dh_callback''(3),
1210 ''SSL_CTX_set_verify''(3),
1211 ''SSL_CTX_use_certificate''(3),
1212 ''SSL_alert_type_string''(3), ''SSL_get_SSL_CTX''(3),
1213 ''SSL_get_ciphers''(3), ''SSL_get_client_CA_list''(3),
1214 ''SSL_get_default_timeout''(3), ''SSL_get_error''(3),
1215 ''SSL_get_ex_data_X509_STORE_CTX_idx''(3),
1216 ''SSL_get_ex_new_index''(3), ''SSL_get_fd''(3),
1217 ''SSL_get_peer_cert_chain''(3), ''SSL_get_rbio''(3),
1218 ''SSL_get_session''(3), ''SSL_get_verify_result''(3),
1219 ''SSL_get_version''(3), ''SSL_library_init''(3),
1220 ''SSL_load_client_CA_file''(3), ''SSL_new''(3),
1221 ''SSL_pending''(3), ''SSL_read''(3),
1222 ''SSL_rstate_string''(3), ''SSL_session_reused''(3),
1223 ''SSL_set_bio''(3), ''SSL_set_connect_state''(3),
1224 ''SSL_set_fd''(3), ''SSL_set_session''(3),
1225 ''SSL_set_shutdown''(3), ''SSL_shutdown''(3),
1226 ''SSL_state_string''(3), ''SSL_want''(3),
1227 ''SSL_write''(3), ''SSL_SESSION_free''(3),
1228 ''SSL_SESSION_get_ex_new_index''(3),
1229 ''SSL_SESSION_get_time''(3),
1230 ''d2i_SSL_SESSION''(3)
1231 !!HISTORY
1232
1233
1234 The ssl(3) document appeared in OpenSSL
1235 0.9.2
1236 ----
This page is a man page (or other imported legacy content). We are unable to automatically determine the license status of this page.