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 enum HANDSHAKE_STATE B<SSL_state>(const SSL *ssl);
 628
 629 Returns the current handshake state.
 630
 631 =item char *B<SSL_state_string>(const SSL *ssl);
 632
 633 =item char *B<SSL_state_string_long>(const SSL *ssl);
 634
 635 =item long B<SSL_total_renegotiations>(SSL *ssl);
 636
 637 =item int B<SSL_use_PrivateKey>(SSL *ssl, EVP_PKEY *pkey);
 638
 639 =item int B<SSL_use_PrivateKey_ASN1>(int type, SSL *ssl, unsigned char *d, long len);
 640
 641 =item int B<SSL_use_PrivateKey_file>(SSL *ssl, char *file, int type);
 642
 643 =item int B<SSL_use_RSAPrivateKey>(SSL *ssl, RSA *rsa);
 644
 645 =item int B<SSL_use_RSAPrivateKey_ASN1>(SSL *ssl, unsigned char *d, long len);
 646
 647 =item int B<SSL_use_RSAPrivateKey_file>(SSL *ssl, char *file, int type);
 648
 649 =item int B<SSL_use_certificate>(SSL *ssl, X509 *x);
 650
 651 =item int B<SSL_use_certificate_ASN1>(SSL *ssl, int len, unsigned char *d);
 652
 653 =item int B<SSL_use_certificate_file>(SSL *ssl, char *file, int type);
 654
 655 =item int B<SSL_version>(const SSL *ssl);
 656
 657 =item int B<SSL_want>(const SSL *ssl);
 658
 659 =item int B<SSL_want_nothing>(const SSL *ssl);
 660
 661 =item int B<SSL_want_read>(const SSL *ssl);
 662
 663 =item int B<SSL_want_write>(const SSL *ssl);
 664
 665 =item int B<SSL_want_x509_lookup>(const SSL *ssl);
 666
 667 =item int B<SSL_write>(SSL *ssl, const void *buf, int num);
 668
 669 =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));
 670
 671 =item int B<SSL_use_psk_identity_hint>(SSL *ssl, const char *hint);
 672
 673 =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));
 674
 675 =item const char *B<SSL_get_psk_identity_hint>(SSL *ssl);
 676
 677 =item const char *B<SSL_get_psk_identity>(SSL *ssl);
 678
 679 =back
 680
 681 =head1 SEE ALSO
 682
 683 L<openssl(1)>, L<crypto(3)>,
 684 L<SSL_accept(3)>, L<SSL_clear(3)>,
 685 L<SSL_connect(3)>,
 686 L<SSL_CIPHER_get_name(3)>,
 687 L<SSL_COMP_add_compression_method(3)>,
 688 L<SSL_CTX_add_extra_chain_cert(3)>,
 689 L<SSL_CTX_add_session(3)>,
 690 L<SSL_CTX_ctrl(3)>,
 691 L<SSL_CTX_flush_sessions(3)>,
 692 L<SSL_CTX_get_ex_new_index(3)>,
 693 L<SSL_CTX_get_verify_mode(3)>,
 694 L<SSL_CTX_load_verify_locations(3)>
 695 L<SSL_CTX_new(3)>,
 696 L<SSL_CTX_sess_number(3)>,
 697 L<SSL_CTX_sess_set_cache_size(3)>,
 698 L<SSL_CTX_sess_set_get_cb(3)>,
 699 L<SSL_CTX_sessions(3)>,
 700 L<SSL_CTX_set_cert_store(3)>,
 701 L<SSL_CTX_set_cert_verify_callback(3)>,
 702 L<SSL_CTX_set_cipher_list(3)>,
 703 L<SSL_CTX_set_client_CA_list(3)>,
 704 L<SSL_CTX_set_client_cert_cb(3)>,
 705 L<SSL_CTX_set_default_passwd_cb(3)>,
 706 L<SSL_CTX_set_generate_session_id(3)>,
 707 L<SSL_CTX_set_info_callback(3)>,
 708 L<SSL_CTX_set_max_cert_list(3)>,
 709 L<SSL_CTX_set_mode(3)>,
 710 L<SSL_CTX_set_msg_callback(3)>,
 711 L<SSL_CTX_set_options(3)>,
 712 L<SSL_CTX_set_quiet_shutdown(3)>,
 713 L<SSL_CTX_set_read_ahead(3)>,
 714 L<SSL_CTX_set_session_cache_mode(3)>,
 715 L<SSL_CTX_set_session_id_context(3)>,
 716 L<SSL_CTX_set_ssl_version(3)>,
 717 L<SSL_CTX_set_timeout(3)>,
 718 L<SSL_CTX_set_tmp_rsa_callback(3)>,
 719 L<SSL_CTX_set_tmp_dh_callback(3)>,
 720 L<SSL_CTX_set_verify(3)>,
 721 L<SSL_CTX_use_certificate(3)>,
 722 L<SSL_alert_type_string(3)>,
 723 L<SSL_do_handshake(3)>,
 724 L<SSL_get_SSL_CTX(3)>,
 725 L<SSL_get_ciphers(3)>,
 726 L<SSL_get_client_CA_list(3)>,
 727 L<SSL_get_default_timeout(3)>,
 728 L<SSL_get_error(3)>,
 729 L<SSL_get_ex_data_X509_STORE_CTX_idx(3)>,
 730 L<SSL_get_ex_new_index(3)>,
 731 L<SSL_get_fd(3)>,
 732 L<SSL_get_peer_cert_chain(3)>,
 733 L<SSL_get_rbio(3)>,
 734 L<SSL_get_session(3)>,
 735 L<SSL_get_verify_result(3)>,
 736 L<SSL_get_version(3)>,
 737 L<SSL_library_init(3)>,
 738 L<SSL_load_client_CA_file(3)>,
 739 L<SSL_new(3)>,
 740 L<SSL_pending(3)>,
 741 L<SSL_read(3)>,
 742 L<SSL_rstate_string(3)>,
 743 L<SSL_session_reused(3)>,
 744 L<SSL_set_bio(3)>,
 745 L<SSL_set_connect_state(3)>,
 746 L<SSL_set_fd(3)>,
 747 L<SSL_set_session(3)>,
 748 L<SSL_set_shutdown(3)>,
 749 L<SSL_shutdown(3)>,
 750 L<SSL_state_string(3)>,
 751 L<SSL_want(3)>,
 752 L<SSL_write(3)>,
 753 L<SSL_SESSION_free(3)>,
 754 L<SSL_SESSION_get_ex_new_index(3)>,
 755 L<SSL_SESSION_get_time(3)>,
 756 L<d2i_SSL_SESSION(3)>,
 757 L<SSL_CTX_set_psk_client_callback(3)>,
 758 L<SSL_CTX_use_psk_identity_hint(3)>,
 759 L<SSL_get_psk_identity(3)>,
 760 L<DTLSv1_listen(3)|DTLSv1_listen(3)>
 761
 762 =head1 HISTORY
 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