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