view release on metacpan or  search on metacpan

lib/Net/SSLeay/OO/SSL.pm  view on Meta::CPAN

=cut

sub get_session {
	my $self = shift;
	require Net::SSLeay::OO::Session;
	my $sessid = Net::SSLeay::get1_session( $self->ssl );
	&Net::SSLeay::OO::Error::die_if_ssl_error("get_session");
	if ($sessid) {
		Net::SSLeay::OO::Session->new( session => $sessid );
	}
}

sub set_session {
	my $self    = shift;
	my $session = shift;
	Net::SSLeay::set_session( $self->ssl, $session->session );
	&Net::SSLeay::OO::Error::die_if_ssl_error("set_session");
}

=item B<state_string>

=item B<state_string_long>

Return a codified or human-readable string 'indicating the current
state of the SSL object'.

L<SSL_state_string(3ssl)> sez ''Detailed description of possible
states to be included later''

=item B<rstate_string>

=item B<rstate_string_long>

Return information about the read state.  In a blocking environment,
this should always return "RD" or "read done".  Otherwise, you'll get
something else possibly informative.

=back

=head2 Un-triaged

The following methods I haven't looked at at all; if you use them in a
program, please submit a patch which moves them into one of the above
categories.  The best information about them will be found on the
relevant SSL man page - use C<man -k> or C<apropros> to find a useful
man page.

My policy on these is that no function should take an unwrapped
pointer argument or return an unwrapped pointer.  So long as the
function you use doesn't do that, you can reasonably expect its call
interface not to change; but of course I place no guarantees should
OpenSSL or Net::SSLeay ruin your day.

 set_cipher_list($list)
 add_client_CA(ssl,x)
 alert_desc_string(value)
 alert_desc_string_long(value)
 alert_type_string(value)
 alert_type_string_long(value)
 callback_ctrl(ssl,i,fp)
 check_private_key(ctx)
 do_handshake(s)
 dup(ssl)
 get_current_cipher(s)
 get_default_timeout(s)
 get_ex_data(ssl,idx)
 get_finished(s,buf,count)
 get_peer_finished(s,buf,count)
 get_quiet_shutdown(ssl)
 get_shutdown(ssl)
 get_verify_depth(s)
 get_verify_mode(s)
 get_verify_result(ssl)
 renegotiate(s)
 set_accept_state(s)
 set_client_CA_list(s,list)
 set_connect_state(s)
 set_ex_data(ssl,idx,data)
 set_info_callback(ssl,cb)
 set_purpose(s,purpose)
 set_quiet_shutdown(ssl,mode)
 set_shutdown(ssl,mode)
 set_trust(s,trust)
 set_verify_depth(s,depth)
 set_verify_result(ssl,v)
 version(ssl)
 load_client_CA_file(file)
 add_file_cert_subjects_to_stack(stackCAs,file)
 add_dir_cert_subjects_to_stack(stackCAs,dir)
 set_session_id_context(ssl,sid_ctx,sid_ctx_len)
 set_tmp_rsa_callback(ssl, cb)
 set_tmp_dh_callback(ssl,dh)
 get_ex_new_index(argl, argp, new_func, dup_func, free_func)
 clear_num_renegotiations(ssl)
 get_app_data(s)
 get_cipher_bits(s,np)
 get_mode(ssl)
 get_state(ssl)
 need_tmp_RSA(ssl)
 num_renegotiations(ssl)
 session_reused(ssl)
 set_app_data(s,arg)
 set_mode(ssl,op)
 set_pref_cipher(s,n)
 set_tmp_dh(ssl,dh)
 set_tmp_rsa(ssl,rsa)
 total_renegotiations(ssl)
 get_client_random(s)
 get_server_random(s)
 get_keyblock_size(s)
 set_hello_extension(s, type, data)
 set_session_secret_cb(s,func,data=NULL)

=cut

# excluded because they were either named badly for their argument
# types, because I didn't want to implement versions which would have
# to take pointers directly as integers, because there was no OpenSSL
# man page for them, or because they were marked as not for general
# consumption.