Document the default CA path functions
[openssl.git] / doc / ssl / ssl.pod
1
2 =pod
3
4 =head1 NAME
5
6 SSL - OpenSSL SSL/TLS library
7
8 =head1 SYNOPSIS
9
10 =head1 DESCRIPTION
11
12 The OpenSSL B<ssl> library implements the Secure Sockets Layer (SSL v2/v3) and
13 Transport Layer Security (TLS v1) protocols. It provides a rich API which is
14 documented here.
15
16 At first the library must be initialized; see
17 L<SSL_library_init(3)>.
18
19 Then an B<SSL_CTX> object is created as a framework to establish
20 TLS/SSL enabled connections (see L<SSL_CTX_new(3)>).
21 Various options regarding certificates, algorithms etc. can be set
22 in this object.
23
24 When a network connection has been created, it can be assigned to an
25 B<SSL> object. After the B<SSL> object has been created using
26 L<SSL_new(3)>, L<SSL_set_fd(3)> or
27 L<SSL_set_bio(3)> can be used to associate the network
28 connection with the object.
29
30 Then the TLS/SSL handshake is performed using
31 L<SSL_accept(3)> or L<SSL_connect(3)>
32 respectively.
33 L<SSL_read(3)> and L<SSL_write(3)> are used
34 to read and write data on the TLS/SSL connection.
35 L<SSL_shutdown(3)> can be used to shut down the
36 TLS/SSL connection.
37
38 =head1 DATA STRUCTURES
39
40 Currently the OpenSSL B<ssl> library functions deals with the following data
41 structures:
42
43 =over 4
44
45 =item B<SSL_METHOD> (SSL Method)
46
47 That's a dispatch structure describing the internal B<ssl> library
48 methods/functions which implement the various protocol versions (SSLv3
49 TLSv1, ...). It's needed to create an B<SSL_CTX>.
50
51 =item B<SSL_CIPHER> (SSL Cipher)
52
53 This structure holds the algorithm information for a particular cipher which
54 are a core part of the SSL/TLS protocol. The available ciphers are configured
55 on a B<SSL_CTX> basis and the actually used ones are then part of the
56 B<SSL_SESSION>.
57
58 =item B<SSL_CTX> (SSL Context)
59
60 That's the global context structure which is created by a server or client
61 once per program life-time and which holds mainly default values for the
62 B<SSL> structures which are later created for the connections.
63
64 =item B<SSL_SESSION> (SSL Session)
65
66 This is a structure containing the current TLS/SSL session details for a
67 connection: B<SSL_CIPHER>s, client and server certificates, keys, etc.
68
69 =item B<SSL> (SSL Connection)
70
71 That's the main SSL/TLS structure which is created by a server or client per
72 established connection. This actually is the core structure in the SSL API.
73 Under run-time the application usually deals with this structure which has
74 links to mostly all other structures.
75
76 =back
77
78
79 =head1 HEADER FILES
80
81 Currently the OpenSSL B<ssl> library provides the following C header files
82 containing the prototypes for the data structures and and functions:
83
84 =over 4
85
86 =item B<ssl.h>
87
88 That's the common header file for the SSL/TLS API.  Include it into your
89 program to make the API of the B<ssl> library available. It internally
90 includes both more private SSL headers and headers from the B<crypto> library.
91 Whenever you need hard-core details on the internals of the SSL API, look
92 inside this header file.
93
94 =item B<ssl2.h>
95
96 That's the sub header file dealing with the SSLv2 protocol only.
97 I<Usually you don't have to include it explicitly because
98 it's already included by ssl.h>.
99
100 =item B<ssl3.h>
101
102 That's the sub header file dealing with the SSLv3 protocol only.
103 I<Usually you don't have to include it explicitly because
104 it's already included by ssl.h>.
105
106 =item B<tls1.h>
107
108 That's the sub header file dealing with the TLSv1 protocol only.
109 I<Usually you don't have to include it explicitly because
110 it's already included by ssl.h>.
111
112 =back
113
114 =head1 API FUNCTIONS
115
116 Currently the OpenSSL B<ssl> library exports 214 API functions.
117 They are documented in the following:
118
119 =head2 DEALING WITH PROTOCOL METHODS
120
121 Here we document the various API functions which deal with the SSL/TLS
122 protocol methods defined in B<SSL_METHOD> structures.
123
124 =over 4
125
126 =item const SSL_METHOD *B<SSLv3_client_method>(void);
127
128 Constructor for the SSLv3 SSL_METHOD structure for a dedicated client.
129
130 =item const SSL_METHOD *B<SSLv3_server_method>(void);
131
132 Constructor for the SSLv3 SSL_METHOD structure for a dedicated server.
133
134 =item const SSL_METHOD *B<SSLv3_method>(void);
135
136 Constructor for the SSLv3 SSL_METHOD structure for combined client and server.
137
138 =item const SSL_METHOD *B<TLSv1_client_method>(void);
139
140 Constructor for the TLSv1 SSL_METHOD structure for a dedicated client.
141
142 =item const SSL_METHOD *B<TLSv1_server_method>(void);
143
144 Constructor for the TLSv1 SSL_METHOD structure for a dedicated server.
145
146 =item const SSL_METHOD *B<TLSv1_method>(void);
147
148 Constructor for the TLSv1 SSL_METHOD structure for combined client and server.
149
150 =back
151
152 =head2 DEALING WITH CIPHERS
153
154 Here we document the various API functions which deal with the SSL/TLS
155 ciphers defined in B<SSL_CIPHER> structures.
156
157 =over 4
158
159 =item char *B<SSL_CIPHER_description>(SSL_CIPHER *cipher, char *buf, int len);
160
161 Write a string to I<buf> (with a maximum size of I<len>) containing a human
162 readable description of I<cipher>. Returns I<buf>.
163
164 =item int B<SSL_CIPHER_get_bits>(SSL_CIPHER *cipher, int *alg_bits);
165
166 Determine the number of bits in I<cipher>. Because of export crippled ciphers
167 there are two bits: The bits the algorithm supports in general (stored to
168 I<alg_bits>) and the bits which are actually used (the return value).
169
170 =item const char *B<SSL_CIPHER_get_name>(SSL_CIPHER *cipher);
171
172 Return the internal name of I<cipher> as a string. These are the various
173 strings defined by the I<SSL3_TXT_xxx> and I<TLS1_TXT_xxx>
174 definitions in the header files.
175
176 =item char *B<SSL_CIPHER_get_version>(SSL_CIPHER *cipher);
177
178 Returns a string like "C<TLSv1/SSLv3>" or "C<SSLv2>" which indicates the
179 SSL/TLS protocol version to which I<cipher> belongs (i.e. where it was defined
180 in the specification the first time).
181
182 =back
183
184 =head2 DEALING WITH PROTOCOL CONTEXTS
185
186 Here we document the various API functions which deal with the SSL/TLS
187 protocol context defined in the B<SSL_CTX> structure.
188
189 =over 4
190
191 =item int B<SSL_CTX_add_client_CA>(SSL_CTX *ctx, X509 *x);
192
193 =item long B<SSL_CTX_add_extra_chain_cert>(SSL_CTX *ctx, X509 *x509);
194
195 =item int B<SSL_CTX_add_session>(SSL_CTX *ctx, SSL_SESSION *c);
196
197 =item int B<SSL_CTX_check_private_key>(const SSL_CTX *ctx);
198
199 =item long B<SSL_CTX_ctrl>(SSL_CTX *ctx, int cmd, long larg, char *parg);
200
201 =item void B<SSL_CTX_flush_sessions>(SSL_CTX *s, long t);
202
203 =item void B<SSL_CTX_free>(SSL_CTX *a);
204
205 =item char *B<SSL_CTX_get_app_data>(SSL_CTX *ctx);
206
207 =item X509_STORE *B<SSL_CTX_get_cert_store>(SSL_CTX *ctx);
208
209 =item STACK *B<SSL_CTX_get_client_CA_list>(const SSL_CTX *ctx);
210
211 =item int (*B<SSL_CTX_get_client_cert_cb>(SSL_CTX *ctx))(SSL *ssl, X509 **x509, EVP_PKEY **pkey);
212
213 =item void B<SSL_CTX_get_default_read_ahead>(SSL_CTX *ctx);
214
215 =item char *B<SSL_CTX_get_ex_data>(const SSL_CTX *s, int idx);
216
217 =item int B<SSL_CTX_get_ex_new_index>(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))
218
219 =item void (*B<SSL_CTX_get_info_callback>(SSL_CTX *ctx))(SSL *ssl, int cb, int ret);
220
221 =item int B<SSL_CTX_get_quiet_shutdown>(const SSL_CTX *ctx);
222
223 =item void B<SSL_CTX_get_read_ahead>(SSL_CTX *ctx);
224
225 =item int B<SSL_CTX_get_session_cache_mode>(SSL_CTX *ctx);
226
227 =item long B<SSL_CTX_get_timeout>(const SSL_CTX *ctx);
228
229 =item int (*B<SSL_CTX_get_verify_callback>(const SSL_CTX *ctx))(int ok, X509_STORE_CTX *ctx);
230
231 =item int B<SSL_CTX_get_verify_mode>(SSL_CTX *ctx);
232
233 =item int B<SSL_CTX_load_verify_locations>(SSL_CTX *ctx, char *CAfile, char *CApath);
234
235 =item long B<SSL_CTX_need_tmp_RSA>(SSL_CTX *ctx);
236
237 =item SSL_CTX *B<SSL_CTX_new>(const SSL_METHOD *meth);
238
239 =item int B<SSL_CTX_remove_session>(SSL_CTX *ctx, SSL_SESSION *c);
240
241 =item int B<SSL_CTX_sess_accept>(SSL_CTX *ctx);
242
243 =item int B<SSL_CTX_sess_accept_good>(SSL_CTX *ctx);
244
245 =item int B<SSL_CTX_sess_accept_renegotiate>(SSL_CTX *ctx);
246
247 =item int B<SSL_CTX_sess_cache_full>(SSL_CTX *ctx);
248
249 =item int B<SSL_CTX_sess_cb_hits>(SSL_CTX *ctx);
250
251 =item int B<SSL_CTX_sess_connect>(SSL_CTX *ctx);
252
253 =item int B<SSL_CTX_sess_connect_good>(SSL_CTX *ctx);
254
255 =item int B<SSL_CTX_sess_connect_renegotiate>(SSL_CTX *ctx);
256
257 =item int B<SSL_CTX_sess_get_cache_size>(SSL_CTX *ctx);
258
259 =item SSL_SESSION *(*B<SSL_CTX_sess_get_get_cb>(SSL_CTX *ctx))(SSL *ssl, unsigned char *data, int len, int *copy);
260
261 =item int (*B<SSL_CTX_sess_get_new_cb>(SSL_CTX *ctx)(SSL *ssl, SSL_SESSION *sess);
262
263 =item void (*B<SSL_CTX_sess_get_remove_cb>(SSL_CTX *ctx)(SSL_CTX *ctx, SSL_SESSION *sess);
264
265 =item int B<SSL_CTX_sess_hits>(SSL_CTX *ctx);
266
267 =item int B<SSL_CTX_sess_misses>(SSL_CTX *ctx);
268
269 =item int B<SSL_CTX_sess_number>(SSL_CTX *ctx);
270
271 =item void B<SSL_CTX_sess_set_cache_size>(SSL_CTX *ctx,t);
272
273 =item void B<SSL_CTX_sess_set_get_cb>(SSL_CTX *ctx, SSL_SESSION *(*cb)(SSL *ssl, unsigned char *data, int len, int *copy));
274
275 =item void B<SSL_CTX_sess_set_new_cb>(SSL_CTX *ctx, int (*cb)(SSL *ssl, SSL_SESSION *sess));
276
277 =item void B<SSL_CTX_sess_set_remove_cb>(SSL_CTX *ctx, void (*cb)(SSL_CTX *ctx, SSL_SESSION *sess));
278
279 =item int B<SSL_CTX_sess_timeouts>(SSL_CTX *ctx);
280
281 =item LHASH *B<SSL_CTX_sessions>(SSL_CTX *ctx);
282
283 =item void B<SSL_CTX_set_app_data>(SSL_CTX *ctx, void *arg);
284
285 =item void B<SSL_CTX_set_cert_store>(SSL_CTX *ctx, X509_STORE *cs);
286
287 =item void B<SSL_CTX_set_cert_verify_cb>(SSL_CTX *ctx, int (*cb)(), char *arg)
288
289 =item int B<SSL_CTX_set_cipher_list>(SSL_CTX *ctx, char *str);
290
291 =item void B<SSL_CTX_set_client_CA_list>(SSL_CTX *ctx, STACK *list);
292
293 =item void B<SSL_CTX_set_client_cert_cb>(SSL_CTX *ctx, int (*cb)(SSL *ssl, X509 **x509, EVP_PKEY **pkey));
294
295 =item void B<SSL_CTX_set_default_passwd_cb>(SSL_CTX *ctx, int (*cb);(void))
296
297 =item void B<SSL_CTX_set_default_read_ahead>(SSL_CTX *ctx, int m);
298
299 =item int B<SSL_CTX_set_default_verify_paths>(SSL_CTX *ctx);
300
301 Use the default paths to locate trusted CA certificates. There is one default
302 directory path and one default file path. Both are set via this call.
303
304 =item int B<SSL_CTX_set_default_verify_dir>(SSL_CTX *ctx)
305
306 Use the default directory path to locate trusted CA certficates.
307
308 =item int B<SSL_CTX_set_default_verify_file>(SSL_CTX *ctx)
309
310 Use the file path to locate trusted CA certficates.
311
312 =item int B<SSL_CTX_set_ex_data>(SSL_CTX *s, int idx, char *arg);
313
314 =item void B<SSL_CTX_set_info_callback>(SSL_CTX *ctx, void (*cb)(SSL *ssl, int cb, int ret));
315
316 =item void B<SSL_CTX_set_msg_callback>(SSL_CTX *ctx, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg));
317
318 =item void B<SSL_CTX_set_msg_callback_arg>(SSL_CTX *ctx, void *arg);
319
320 =item void B<SSL_CTX_set_options>(SSL_CTX *ctx, unsigned long op);
321
322 =item void B<SSL_CTX_set_quiet_shutdown>(SSL_CTX *ctx, int mode);
323
324 =item void B<SSL_CTX_set_read_ahead>(SSL_CTX *ctx, int m);
325
326 =item void B<SSL_CTX_set_session_cache_mode>(SSL_CTX *ctx, int mode);
327
328 =item int B<SSL_CTX_set_ssl_version>(SSL_CTX *ctx, const SSL_METHOD *meth);
329
330 =item void B<SSL_CTX_set_timeout>(SSL_CTX *ctx, long t);
331
332 =item long B<SSL_CTX_set_tmp_dh>(SSL_CTX* ctx, DH *dh);
333
334 =item long B<SSL_CTX_set_tmp_dh_callback>(SSL_CTX *ctx, DH *(*cb)(void));
335
336 =item long B<SSL_CTX_set_tmp_rsa>(SSL_CTX *ctx, RSA *rsa);
337
338 =item SSL_CTX_set_tmp_rsa_callback
339
340 C<long B<SSL_CTX_set_tmp_rsa_callback>(SSL_CTX *B<ctx>, RSA *(*B<cb>)(SSL *B<ssl>, int B<export>, int B<keylength>));>
341
342 Sets the callback which will be called when a temporary private key is
343 required. The B<C<export>> flag will be set if the reason for needing
344 a temp key is that an export ciphersuite is in use, in which case,
345 B<C<keylength>> will contain the required keylength in bits. Generate a key of
346 appropriate size (using ???) and return it.
347
348 =item SSL_set_tmp_rsa_callback
349
350 long B<SSL_set_tmp_rsa_callback>(SSL *ssl, RSA *(*cb)(SSL *ssl, int export, int keylength));
351
352 The same as B<SSL_CTX_set_tmp_rsa_callback>, except it operates on an SSL
353 session instead of a context.
354
355 =item void B<SSL_CTX_set_verify>(SSL_CTX *ctx, int mode, int (*cb);(void))
356
357 =item int B<SSL_CTX_use_PrivateKey>(SSL_CTX *ctx, EVP_PKEY *pkey);
358
359 =item int B<SSL_CTX_use_PrivateKey_ASN1>(int type, SSL_CTX *ctx, unsigned char *d, long len);
360
361 =item int B<SSL_CTX_use_PrivateKey_file>(SSL_CTX *ctx, char *file, int type);
362
363 =item int B<SSL_CTX_use_RSAPrivateKey>(SSL_CTX *ctx, RSA *rsa);
364
365 =item int B<SSL_CTX_use_RSAPrivateKey_ASN1>(SSL_CTX *ctx, unsigned char *d, long len);
366
367 =item int B<SSL_CTX_use_RSAPrivateKey_file>(SSL_CTX *ctx, char *file, int type);
368
369 =item int B<SSL_CTX_use_certificate>(SSL_CTX *ctx, X509 *x);
370
371 =item int B<SSL_CTX_use_certificate_ASN1>(SSL_CTX *ctx, int len, unsigned char *d);
372
373 =item int B<SSL_CTX_use_certificate_file>(SSL_CTX *ctx, char *file, int type);
374
375 =item X509 *B<SSL_CTX_get0_certificate>(const SSL_CTX *ctx);
376
377 =item EVP_PKEY *B<SSL_CTX_get0_privatekey>(const SSL_CTX *ctx);
378
379 =item void B<SSL_CTX_set_psk_client_callback>(SSL_CTX *ctx, unsigned int (*callback)(SSL *ssl, const char *hint, char *identity, unsigned int max_identity_len, unsigned char *psk, unsigned int max_psk_len));
380
381 =item int B<SSL_CTX_use_psk_identity_hint>(SSL_CTX *ctx, const char *hint);
382
383 =item void B<SSL_CTX_set_psk_server_callback>(SSL_CTX *ctx, unsigned int (*callback)(SSL *ssl, const char *identity, unsigned char *psk, int max_psk_len));
384
385
386
387
388 =back
389
390 =head2 DEALING WITH SESSIONS
391
392 Here we document the various API functions which deal with the SSL/TLS
393 sessions defined in the B<SSL_SESSION> structures.
394
395 =over 4
396
397 =item int B<SSL_SESSION_cmp>(const SSL_SESSION *a, const SSL_SESSION *b);
398
399 =item void B<SSL_SESSION_free>(SSL_SESSION *ss);
400
401 =item char *B<SSL_SESSION_get_app_data>(SSL_SESSION *s);
402
403 =item char *B<SSL_SESSION_get_ex_data>(const SSL_SESSION *s, int idx);
404
405 =item int B<SSL_SESSION_get_ex_new_index>(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))
406
407 =item long B<SSL_SESSION_get_time>(const SSL_SESSION *s);
408
409 =item long B<SSL_SESSION_get_timeout>(const SSL_SESSION *s);
410
411 =item unsigned long B<SSL_SESSION_hash>(const SSL_SESSION *a);
412
413 =item SSL_SESSION *B<SSL_SESSION_new>(void);
414
415 =item int B<SSL_SESSION_print>(BIO *bp, const SSL_SESSION *x);
416
417 =item int B<SSL_SESSION_print_fp>(FILE *fp, const SSL_SESSION *x);
418
419 =item void B<SSL_SESSION_set_app_data>(SSL_SESSION *s, char *a);
420
421 =item int B<SSL_SESSION_set_ex_data>(SSL_SESSION *s, int idx, char *arg);
422
423 =item long B<SSL_SESSION_set_time>(SSL_SESSION *s, long t);
424
425 =item long B<SSL_SESSION_set_timeout>(SSL_SESSION *s, long t);
426
427 =back
428
429 =head2 DEALING WITH CONNECTIONS
430
431 Here we document the various API functions which deal with the SSL/TLS
432 connection defined in the B<SSL> structure.
433
434 =over 4
435
436 =item int B<SSL_accept>(SSL *ssl);
437
438 =item int B<SSL_add_dir_cert_subjects_to_stack>(STACK *stack, const char *dir);
439
440 =item int B<SSL_add_file_cert_subjects_to_stack>(STACK *stack, const char *file);
441
442 =item int B<SSL_add_client_CA>(SSL *ssl, X509 *x);
443
444 =item char *B<SSL_alert_desc_string>(int value);
445
446 =item char *B<SSL_alert_desc_string_long>(int value);
447
448 =item char *B<SSL_alert_type_string>(int value);
449
450 =item char *B<SSL_alert_type_string_long>(int value);
451
452 =item int B<SSL_check_private_key>(const SSL *ssl);
453
454 =item void B<SSL_clear>(SSL *ssl);
455
456 =item long B<SSL_clear_num_renegotiations>(SSL *ssl);
457
458 =item int B<SSL_connect>(SSL *ssl);
459
460 =item int B<SSL_copy_session_id>(SSL *t, const SSL *f);
461
462 Sets the session details for B<t> to be the same as in B<f>. Returns 1 on
463 success or 0 on failure.
464
465 =item long B<SSL_ctrl>(SSL *ssl, int cmd, long larg, char *parg);
466
467 =item int B<SSL_do_handshake>(SSL *ssl);
468
469 =item SSL *B<SSL_dup>(SSL *ssl);
470
471 =item STACK *B<SSL_dup_CA_list>(STACK *sk);
472
473 =item void B<SSL_free>(SSL *ssl);
474
475 =item SSL_CTX *B<SSL_get_SSL_CTX>(const SSL *ssl);
476
477 =item char *B<SSL_get_app_data>(SSL *ssl);
478
479 =item X509 *B<SSL_get_certificate>(const SSL *ssl);
480
481 =item const char *B<SSL_get_cipher>(const SSL *ssl);
482
483 =item int B<SSL_get_cipher_bits>(const SSL *ssl, int *alg_bits);
484
485 =item char *B<SSL_get_cipher_list>(const SSL *ssl, int n);
486
487 =item char *B<SSL_get_cipher_name>(const SSL *ssl);
488
489 =item char *B<SSL_get_cipher_version>(const SSL *ssl);
490
491 =item STACK *B<SSL_get_ciphers>(const SSL *ssl);
492
493 =item STACK *B<SSL_get_client_CA_list>(const SSL *ssl);
494
495 =item SSL_CIPHER *B<SSL_get_current_cipher>(SSL *ssl);
496
497 =item long B<SSL_get_default_timeout>(const SSL *ssl);
498
499 =item int B<SSL_get_error>(const SSL *ssl, int i);
500
501 =item char *B<SSL_get_ex_data>(const SSL *ssl, int idx);
502
503 =item int B<SSL_get_ex_data_X509_STORE_CTX_idx>(void);
504
505 =item int B<SSL_get_ex_new_index>(long argl, char *argp, int (*new_func);(void), int (*dup_func)(void), void (*free_func)(void))
506
507 =item int B<SSL_get_fd>(const SSL *ssl);
508
509 =item void (*B<SSL_get_info_callback>(const SSL *ssl);)()
510
511 =item STACK *B<SSL_get_peer_cert_chain>(const SSL *ssl);
512
513 =item X509 *B<SSL_get_peer_certificate>(const SSL *ssl);
514
515 =item EVP_PKEY *B<SSL_get_privatekey>(const SSL *ssl);
516
517 =item int B<SSL_get_quiet_shutdown>(const SSL *ssl);
518
519 =item BIO *B<SSL_get_rbio>(const SSL *ssl);
520
521 =item int B<SSL_get_read_ahead>(const SSL *ssl);
522
523 =item SSL_SESSION *B<SSL_get_session>(const SSL *ssl);
524
525 =item char *B<SSL_get_shared_ciphers>(const SSL *ssl, char *buf, int len);
526
527 =item int B<SSL_get_shutdown>(const SSL *ssl);
528
529 =item const SSL_METHOD *B<SSL_get_ssl_method>(SSL *ssl);
530
531 =item int B<SSL_get_state>(const SSL *ssl);
532
533 =item long B<SSL_get_time>(const SSL *ssl);
534
535 =item long B<SSL_get_timeout>(const SSL *ssl);
536
537 =item int (*B<SSL_get_verify_callback>(const SSL *ssl))(int,X509_STORE_CTX *)
538
539 =item int B<SSL_get_verify_mode>(const SSL *ssl);
540
541 =item long B<SSL_get_verify_result>(const SSL *ssl);
542
543 =item char *B<SSL_get_version>(const SSL *ssl);
544
545 =item BIO *B<SSL_get_wbio>(const SSL *ssl);
546
547 =item int B<SSL_in_accept_init>(SSL *ssl);
548
549 =item int B<SSL_in_before>(SSL *ssl);
550
551 =item int B<SSL_in_connect_init>(SSL *ssl);
552
553 =item int B<SSL_in_init>(SSL *ssl);
554
555 =item int B<SSL_is_init_finished>(SSL *ssl);
556
557 =item STACK *B<SSL_load_client_CA_file>(char *file);
558
559 =item void B<SSL_load_error_strings>(void);
560
561 =item SSL *B<SSL_new>(SSL_CTX *ctx);
562
563 =item long B<SSL_num_renegotiations>(SSL *ssl);
564
565 =item int B<SSL_peek>(SSL *ssl, void *buf, int num);
566
567 =item int B<SSL_pending>(const SSL *ssl);
568
569 =item int B<SSL_read>(SSL *ssl, void *buf, int num);
570
571 =item int B<SSL_renegotiate>(SSL *ssl);
572
573 =item char *B<SSL_rstate_string>(SSL *ssl);
574
575 =item char *B<SSL_rstate_string_long>(SSL *ssl);
576
577 =item long B<SSL_session_reused>(SSL *ssl);
578
579 =item void B<SSL_set_accept_state>(SSL *ssl);
580
581 =item void B<SSL_set_app_data>(SSL *ssl, char *arg);
582
583 =item void B<SSL_set_bio>(SSL *ssl, BIO *rbio, BIO *wbio);
584
585 =item int B<SSL_set_cipher_list>(SSL *ssl, char *str);
586
587 =item void B<SSL_set_client_CA_list>(SSL *ssl, STACK *list);
588
589 =item void B<SSL_set_connect_state>(SSL *ssl);
590
591 =item int B<SSL_set_ex_data>(SSL *ssl, int idx, char *arg);
592
593 =item int B<SSL_set_fd>(SSL *ssl, int fd);
594
595 =item void B<SSL_set_info_callback>(SSL *ssl, void (*cb);(void))
596
597 =item void B<SSL_set_msg_callback>(SSL *ctx, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg));
598
599 =item void B<SSL_set_msg_callback_arg>(SSL *ctx, void *arg);
600
601 =item void B<SSL_set_options>(SSL *ssl, unsigned long op);
602
603 =item void B<SSL_set_quiet_shutdown>(SSL *ssl, int mode);
604
605 =item void B<SSL_set_read_ahead>(SSL *ssl, int yes);
606
607 =item int B<SSL_set_rfd>(SSL *ssl, int fd);
608
609 =item int B<SSL_set_session>(SSL *ssl, SSL_SESSION *session);
610
611 =item void B<SSL_set_shutdown>(SSL *ssl, int mode);
612
613 =item int B<SSL_set_ssl_method>(SSL *ssl, const SSL_METHOD *meth);
614
615 =item void B<SSL_set_time>(SSL *ssl, long t);
616
617 =item void B<SSL_set_timeout>(SSL *ssl, long t);
618
619 =item void B<SSL_set_verify>(SSL *ssl, int mode, int (*callback);(void))
620
621 =item void B<SSL_set_verify_result>(SSL *ssl, long arg);
622
623 =item int B<SSL_set_wfd>(SSL *ssl, int fd);
624
625 =item int B<SSL_shutdown>(SSL *ssl);
626
627 =item int B<SSL_state>(const SSL *ssl);
628
629 =item char *B<SSL_state_string>(const SSL *ssl);
630
631 =item char *B<SSL_state_string_long>(const SSL *ssl);
632
633 =item long B<SSL_total_renegotiations>(SSL *ssl);
634
635 =item int B<SSL_use_PrivateKey>(SSL *ssl, EVP_PKEY *pkey);
636
637 =item int B<SSL_use_PrivateKey_ASN1>(int type, SSL *ssl, unsigned char *d, long len);
638
639 =item int B<SSL_use_PrivateKey_file>(SSL *ssl, char *file, int type);
640
641 =item int B<SSL_use_RSAPrivateKey>(SSL *ssl, RSA *rsa);
642
643 =item int B<SSL_use_RSAPrivateKey_ASN1>(SSL *ssl, unsigned char *d, long len);
644
645 =item int B<SSL_use_RSAPrivateKey_file>(SSL *ssl, char *file, int type);
646
647 =item int B<SSL_use_certificate>(SSL *ssl, X509 *x);
648
649 =item int B<SSL_use_certificate_ASN1>(SSL *ssl, int len, unsigned char *d);
650
651 =item int B<SSL_use_certificate_file>(SSL *ssl, char *file, int type);
652
653 =item int B<SSL_version>(const SSL *ssl);
654
655 =item int B<SSL_want>(const SSL *ssl);
656
657 =item int B<SSL_want_nothing>(const SSL *ssl);
658
659 =item int B<SSL_want_read>(const SSL *ssl);
660
661 =item int B<SSL_want_write>(const SSL *ssl);
662
663 =item int B<SSL_want_x509_lookup>(const SSL *ssl);
664
665 =item int B<SSL_write>(SSL *ssl, const void *buf, int num);
666
667 =item void B<SSL_set_psk_client_callback>(SSL *ssl, unsigned int (*callback)(SSL *ssl, const char *hint, char *identity, unsigned int max_identity_len, unsigned char *psk, unsigned int max_psk_len));
668
669 =item int B<SSL_use_psk_identity_hint>(SSL *ssl, const char *hint);
670
671 =item void B<SSL_set_psk_server_callback>(SSL *ssl, unsigned int (*callback)(SSL *ssl, const char *identity, unsigned char *psk, int max_psk_len));
672
673 =item const char *B<SSL_get_psk_identity_hint>(SSL *ssl);
674
675 =item const char *B<SSL_get_psk_identity>(SSL *ssl);
676
677 =back
678
679 =head1 SEE ALSO
680
681 L<openssl(1)>, L<crypto(3)>,
682 L<SSL_accept(3)>, L<SSL_clear(3)>,
683 L<SSL_connect(3)>,
684 L<SSL_CIPHER_get_name(3)>,
685 L<SSL_COMP_add_compression_method(3)>,
686 L<SSL_CTX_add_extra_chain_cert(3)>,
687 L<SSL_CTX_add_session(3)>,
688 L<SSL_CTX_ctrl(3)>,
689 L<SSL_CTX_flush_sessions(3)>,
690 L<SSL_CTX_get_ex_new_index(3)>,
691 L<SSL_CTX_get_verify_mode(3)>,
692 L<SSL_CTX_load_verify_locations(3)>
693 L<SSL_CTX_new(3)>,
694 L<SSL_CTX_sess_number(3)>,
695 L<SSL_CTX_sess_set_cache_size(3)>,
696 L<SSL_CTX_sess_set_get_cb(3)>,
697 L<SSL_CTX_sessions(3)>,
698 L<SSL_CTX_set_cert_store(3)>,
699 L<SSL_CTX_set_cert_verify_callback(3)>,
700 L<SSL_CTX_set_cipher_list(3)>,
701 L<SSL_CTX_set_client_CA_list(3)>,
702 L<SSL_CTX_set_client_cert_cb(3)>,
703 L<SSL_CTX_set_default_passwd_cb(3)>,
704 L<SSL_CTX_set_generate_session_id(3)>,
705 L<SSL_CTX_set_info_callback(3)>,
706 L<SSL_CTX_set_max_cert_list(3)>,
707 L<SSL_CTX_set_mode(3)>,
708 L<SSL_CTX_set_msg_callback(3)>,
709 L<SSL_CTX_set_options(3)>,
710 L<SSL_CTX_set_quiet_shutdown(3)>,
711 L<SSL_CTX_set_read_ahead(3)>,
712 L<SSL_CTX_set_session_cache_mode(3)>,
713 L<SSL_CTX_set_session_id_context(3)>,
714 L<SSL_CTX_set_ssl_version(3)>,
715 L<SSL_CTX_set_timeout(3)>,
716 L<SSL_CTX_set_tmp_rsa_callback(3)>,
717 L<SSL_CTX_set_tmp_dh_callback(3)>,
718 L<SSL_CTX_set_verify(3)>,
719 L<SSL_CTX_use_certificate(3)>,
720 L<SSL_alert_type_string(3)>,
721 L<SSL_do_handshake(3)>,
722 L<SSL_get_SSL_CTX(3)>,
723 L<SSL_get_ciphers(3)>,
724 L<SSL_get_client_CA_list(3)>,
725 L<SSL_get_default_timeout(3)>,
726 L<SSL_get_error(3)>,
727 L<SSL_get_ex_data_X509_STORE_CTX_idx(3)>,
728 L<SSL_get_ex_new_index(3)>,
729 L<SSL_get_fd(3)>,
730 L<SSL_get_peer_cert_chain(3)>,
731 L<SSL_get_rbio(3)>,
732 L<SSL_get_session(3)>,
733 L<SSL_get_verify_result(3)>,
734 L<SSL_get_version(3)>,
735 L<SSL_library_init(3)>,
736 L<SSL_load_client_CA_file(3)>,
737 L<SSL_new(3)>,
738 L<SSL_pending(3)>,
739 L<SSL_read(3)>,
740 L<SSL_rstate_string(3)>,
741 L<SSL_session_reused(3)>,
742 L<SSL_set_bio(3)>,
743 L<SSL_set_connect_state(3)>,
744 L<SSL_set_fd(3)>,
745 L<SSL_set_session(3)>,
746 L<SSL_set_shutdown(3)>,
747 L<SSL_shutdown(3)>,
748 L<SSL_state_string(3)>,
749 L<SSL_want(3)>,
750 L<SSL_write(3)>,
751 L<SSL_SESSION_free(3)>,
752 L<SSL_SESSION_get_ex_new_index(3)>,
753 L<SSL_SESSION_get_time(3)>,
754 L<d2i_SSL_SESSION(3)>,
755 L<SSL_CTX_set_psk_client_callback(3)>,
756 L<SSL_CTX_use_psk_identity_hint(3)>,
757 L<SSL_get_psk_identity(3)>,
758 L<DTLSv1_listen(3)|DTLSv1_listen(3)>
759
760 =head1 HISTORY
761
762 The L<ssl(3)> document appeared in OpenSSL 0.9.2
763
764 B<SSLv2_client_method>, B<SSLv2_server_method> and B<SSLv2_method> where removed
765 in OpenSSL 1.1.0.
766
767 The return type of B<SSL_copy_session_id> was changed from void to int in
768 OpenSSL 1.1.0.
769
770 =cut
771