~ubuntu-branches/ubuntu/quantal/ruby1.9.1/quantal

 * $Id: ossl_ssl.c 32975 2011-08-15 01:20:27Z emboss $

#define numberof(ary) (int)(sizeof(ary)/sizeof((ary)[0]))

#  define TO_SOCKET(s) (s)

        defined(HAVE_SSLV2_CLIENT_METHOD)

    long mode = SSL_MODE_ENABLE_PARTIAL_WRITE;

 

#ifdef SSL_MODE_RELEASE_BUFFERS

    mode |= SSL_MODE_RELEASE_BUFFERS;

#endif

    SSL_CTX_set_mode(ctx, mode);

/*

 * call-seq:

 *    ctx.ssl_version = :TLSv1

 *    ctx.ssl_version = "SSLv23_client"

 *

 * You can get a list of valid versions with OpenSSL::SSL::SSLContext::METHODS

 */

    VALUE obj, success;

                         obj, NULL);

    if (!RTEST(success)) return 0;

    VALUE args[3], success;

                         (VALUE)args, NULL);

    if (!RTEST(success)) return NULL;

    /*

     * return 0 which means to OpenSSL that the the session is still

     * valid (since we created Ruby Session object) and was not freed by us

     * with SSL_SESSION_free(). Call SSLContext#remove_session(sess) in

     * session_get_cb block if you don't want OpenSSL to cache the session

     * internally.

     */

    return 0;

    ret_obj = rb_protect((VALUE(*)_((VALUE)))ossl_call_session_remove_cb, ary, &state);

            ossl_raise(rb_eArgError, "servername_cb must return an OpenSSL::SSL::SSLContext object or nil");

 * Normally you do not need to call this method (unless you are writing an

 * extension in C).

    if(!NIL_P(val)) SSL_CTX_set_verify_depth(ctx, NUM2INT(val));

                                            RSTRING_LENINT(val))){

 *

 * The list of ciphers configured for this context.

    num = sk_SSL_CIPHER_num(ciphers);

        cipher = sk_SSL_CIPHER_value(ciphers, i);

 *

 * Sets the list of available ciphers for this context.  Note in a server

 * context some ciphers require the appropriate certificates.  For example, an

 * RSA cipher can only be chosen when an RSA certificate is available.

 *

 * See also OpenSSL::Cipher and OpenSSL::Cipher::ciphers

 * Adds +session+ to the session cache

 * Removes +session+ from the session cache

 *     ctx.session_cache_mode -> Integer

 * The current session cache mode.

 *     ctx.session_cache_mode=(integer) -> Integer

 * Sets the SSL session cache mode.  Bitwise-or together the desired

 * SESSION_CACHE_* constants to set.  See SSL_CTX_set_session_cache_mode(3) for

 * details.

 *     ctx.session_cache_size -> Integer

 * Returns the current session cache size.  Zero is used to represent an

 * unlimited cache size.

 *     ctx.session_cache_size=(integer) -> Integer

 * Sets the session cache size.  Returns the previously valid session cache

 * size.  Zero is used to represent an unlimited session cache size.

 * Returns a Hash containing the following keys:

 *

 * :accept:: Number of started SSL/TLS handshakes in server mode

 * :accept_good:: Number of established SSL/TLS sessions in server mode

 * :accept_renegotiate:: Number of start renegotiations in server mode

 * :cache_full:: Number of sessions that were removed due to cache overflow

 * :cache_hits:: Number of successfully reused connections

 * :cache_misses:: Number of sessions proposed by clients that were not found

 *                 in the cache

 * :cache_num:: Number of sessions in the internal session cache

 * :cb_hits:: Number of sessions retrieved from the external cache in server

 *            mode

 * :connect:: Number of started SSL/TLS handshakes in client mode

 * :connect_good:: Number of established SSL/TLS sessions in client mode

 * :connect_renegotiate:: Number of start renegotiations in client mode

 * :timeouts:: Number of sessions proposed by clients that were found in the

 *             cache but had expired due to timeouts

 * Removes sessions in the internal cache that have expired at +time+.

        ossl_raise(rb_eArgError, "arg must be Time or nil");

    int i, rc;

 

        /* 4 is from SSL_smart_shutdown() of mod_ssl.c (v2.2.19) */

        /* It says max 2x pending + 2x data = 4 */

        for (i = 0; i < 4; ++i) {

            /*

             * Ignore the case SSL_shutdown returns -1. Empty handshake_func

             * must not happen.

             */

            if (rc = SSL_shutdown(ssl))

                break;

        }

        ERR_clear_error();

        SSL_clear(ssl);

 * Creates a new SSL socket from +io+ which must be a real ruby object (not an

 * IO-like object that responds to read/write.

 *

 * If +ctx+ is provided the SSL Sockets initial params will be taken from

 * the context.

#define ssl_get_error(ssl, ret) (errno = rb_w32_map_errno(WSAGetLastError()), SSL_get_error((ssl), (ret)))

#define ssl_get_error(ssl, ret) SSL_get_error((ssl), (ret))

 *

 * Initiates an SSL/TLS handshake with a server.  The handshake may be started

 * after unencrypted data has been sent over the socket.

 * Initiates the SSL/TLS handshake as a client in non-blocking manner.

 *

 * Waits for a SSL/TLS client to initiate a handshake.  The handshake may be

 * started after unencrypted data has been sent over the socket.

 * Initiates the SSL/TLS handshake as a server in non-blocking manner.

            nread = SSL_read(ssl, RSTRING_PTR(str), RSTRING_LENINT(str));

 * Reads +length+ bytes from the SSL connection.  If a pre-allocated +buffer+

 * is provided the data will be written into it.

 * A non-blocking version of #sysread.  Raises an SSLError if reading would

 * block.

 *

 * Reads +length+ bytes from the SSL connection.  If a pre-allocated +buffer+

 * is provided the data will be written into it.

            nwrite = SSL_write(ssl, RSTRING_PTR(str), RSTRING_LENINT(str));

 *    ssl.syswrite(string) => Integer

 *

 * Writes +string+ to the SSL connection.

 *    ssl.syswrite_nonblock(string) => Integer

 *

 * Writes +string+ to the SSL connection in a non-blocking manner.  Raises an

 * SSLError if writing would block.

 *