Class: OpenSSL::SSL::Session (Ruby 2.2.3)
Description: Class : OpenSSL::SSL::Session - Ruby 2.2.3

- Home
- Core 2.2.3
- Std-lib 2.2.3
- Downloads

Support for the Ruby 2.2 series has ended. See here for reference.

### Home Classes Methods

### In Files

- openssl/ossl_ssl.c

### Parent

Object

### Namespace

- CLASS OpenSSL::SSL::Session::SessionError

### Methods

- ::new
- #==
- #id
- #time
- #time=
- #timeout
- #timeout=
- #to_der
- #to_pem
- #to_text

### Class/Module Index

Quicksearch

- Integer
- OpenSSL::ASN1
- OpenSSL::ASN1::ASN1Data
- OpenSSL::ASN1::ASN1Error
- OpenSSL::ASN1::Constructive
- OpenSSL::ASN1::ObjectId
- OpenSSL::ASN1::Primitive
- OpenSSL::BN
- OpenSSL::BNError
- OpenSSL::Buffering
- OpenSSL::Cipher
- OpenSSL::Cipher::Cipher
- OpenSSL::Cipher::CipherError
- OpenSSL::Config
- OpenSSL::ConfigError
- OpenSSL::Digest
- OpenSSL::Digest::DigestError
- OpenSSL::Engine
- OpenSSL::Engine::EngineError
- OpenSSL::HMAC
- OpenSSL::HMACError
- OpenSSL::Netscape
- OpenSSL::Netscape::SPKI
- OpenSSL::Netscape::SPKIError
- OpenSSL::OCSP
- OpenSSL::OCSP::BasicResponse
- OpenSSL::OCSP::CertificateId
- OpenSSL::OCSP::OCSPError
- OpenSSL::OCSP::Request
- OpenSSL::OCSP::Response
- OpenSSL::OpenSSLError
- OpenSSL::PKCS12
- OpenSSL::PKCS12::PKCS12Error
- OpenSSL::PKCS5
- OpenSSL::PKCS5::PKCS5Error
- OpenSSL::PKCS7
- OpenSSL::PKCS7::PKCS7Error
- OpenSSL::PKCS7::RecipientInfo
- OpenSSL::PKCS7::SignerInfo
- OpenSSL::PKey
- OpenSSL::PKey::DH
- OpenSSL::PKey::DHError
- OpenSSL::PKey::DSA
- OpenSSL::PKey::DSAError
- OpenSSL::PKey::EC
- OpenSSL::PKey::EC::Group
- OpenSSL::PKey::EC::Group::Error
- OpenSSL::PKey::EC::Point
- OpenSSL::PKey::EC::Point::Error
- OpenSSL::PKey::ECError
- OpenSSL::PKey::PKey
- OpenSSL::PKey::PKeyError
- OpenSSL::PKey::RSA
- OpenSSL::PKey::RSAError
- OpenSSL::Random
- OpenSSL::Random::RandomError
- OpenSSL::SSL
- OpenSSL::SSL::Nonblock
- OpenSSL::SSL::SSLContext
- OpenSSL::SSL::SSLError
- OpenSSL::SSL::SSLErrorWaitReadable
- OpenSSL::SSL::SSLErrorWaitWritable
- OpenSSL::SSL::SSLServer
- OpenSSL::SSL::SSLSocket
- OpenSSL::SSL::Session
- OpenSSL::SSL::Session::SessionError
- OpenSSL::SSL::SocketForwarder
- OpenSSL::X509
- OpenSSL::X509::Attribute
- OpenSSL::X509::AttributeError
- OpenSSL::X509::CRL
- OpenSSL::X509::CRLError
- OpenSSL::X509::Certificate
- OpenSSL::X509::CertificateError
- OpenSSL::X509::Extension
- OpenSSL::X509::ExtensionError
- OpenSSL::X509::ExtensionFactory
- OpenSSL::X509::Name
- OpenSSL::X509::Name::RFC2253DN
- OpenSSL::X509::NameError
- OpenSSL::X509::Request
- OpenSSL::X509::RequestError
- OpenSSL::X509::Revoked
- OpenSSL::X509::RevokedError
- OpenSSL::X509::Store
- OpenSSL::X509::StoreContext
- OpenSSL::X509::StoreError
- unknown

No matching classes.

# OpenSSL::SSL::Session

### Public Class Methods

new(SSLSocket | string) => session click to toggle source

### Parameters¶ ↑

`SSLSocket` is an OpenSSL::SSL::SSLSocket `string` must be a DER or PEM encoded Session.

                   static VALUE ossl_ssl_session_initialize(VALUE self, VALUE arg1)
    {
            SSL_SESSION *ctx = NULL;

            if (RDATA(self)->data)
                    ossl_raise(eSSLSession, "SSL Session already initialized");

            if (rb_obj_is_instance_of(arg1, cSSLSocket)) {
                    SSL *ssl;

                    GetSSL(arg1, ssl);

                    if (!ssl || (ctx = SSL_get1_session(ssl)) == NULL)
                            ossl_raise(eSSLSession, "no session available");
            } else {
                    BIO *in = ossl_obj2bio(arg1);

                    ctx = PEM_read_bio_SSL_SESSION(in, NULL, NULL, NULL);

                    if (!ctx) {
                            OSSL_BIO_reset(in);
                            ctx = d2i_SSL_SESSION_bio(in, NULL);
                    }

                    BIO_free(in);

                    if (!ctx)
                            ossl_raise(rb_eArgError, "unknown type");
            }

            /* should not happen */
            if (ctx == NULL)
                    ossl_raise(eSSLSession, "ctx not set - internal error");

            RDATA(self)->data = ctx;

            return self;
    }

### Public Instance Methods

session1 == session2 → boolean click to toggle source

                   static VALUE ossl_ssl_session_eq(VALUE val1, VALUE val2)
    {
            SSL_SESSION *ctx1, *ctx2;

            GetSSLSession(val1, ctx1);
            SafeGetSSLSession(val2, ctx2);

            switch (SSL_SESSION_cmp(ctx1, ctx2)) {
            case 0:                return Qtrue;
            default:       return Qfalse;
            }
    }

id → aString click to toggle source

Returns the Session ID.

                   static VALUE ossl_ssl_session_get_id(VALUE self)
    {
            SSL_SESSION *ctx;
            const unsigned char *p = NULL;
            unsigned int i = 0;

            GetSSLSession(self, ctx);

            p = SSL_SESSION_get_id(ctx, &i);

            return rb_str_new((const char *) p, i);
    }

time → Time click to toggle source

Gets start time of the session.

                   static VALUE ossl_ssl_session_get_time(VALUE self)
    {
            SSL_SESSION *ctx;
            time_t t;

            GetSSLSession(self, ctx);

            t = SSL_SESSION_get_time(ctx);

            if (t == 0)
                    return Qnil;

            return rb_funcall(rb_cTime, rb_intern("at"), 1, TIMET2NUM(t));
    }

time=(Time) → Time click to toggle source
time=(integer) → Time

Sets start time of the session. Time resolution is in seconds.

                   static VALUE ossl_ssl_session_set_time(VALUE self, VALUE time_v)
    {
            SSL_SESSION *ctx;
            long t;

            GetSSLSession(self, ctx);
            if (rb_obj_is_instance_of(time_v, rb_cTime)) {
                    time_v = rb_funcall(time_v, rb_intern("to_i"), 0);
            }
            t = NUM2LONG(time_v);
            SSL_SESSION_set_time(ctx, t);
            return ossl_ssl_session_get_time(self);
    }

timeout → integer click to toggle source

Gets how long until the session expires in seconds.

                   static VALUE ossl_ssl_session_get_timeout(VALUE self)
    {
            SSL_SESSION *ctx;
            time_t t;

            GetSSLSession(self, ctx);

            t = SSL_SESSION_get_timeout(ctx);

            return TIMET2NUM(t);
    }

timeout=(integer) → integer click to toggle source

Sets how long until the session expires in seconds.

                   static VALUE ossl_ssl_session_set_timeout(VALUE self, VALUE time_v)
    {
            SSL_SESSION *ctx;
            long t;

            GetSSLSession(self, ctx);
            t = NUM2LONG(time_v);
            SSL_SESSION_set_timeout(ctx, t);
            return ossl_ssl_session_get_timeout(self);
    }

to_der → aString click to toggle source

Returns an ASN1 encoded String that contains the Session object.

                   static VALUE ossl_ssl_session_to_der(VALUE self)
    {
            SSL_SESSION *ctx;
            unsigned char *p;
            int len;
            VALUE str;

            GetSSLSession(self, ctx);
            len = i2d_SSL_SESSION(ctx, NULL);
            if (len <= 0) {
                    ossl_raise(eSSLSession, "i2d_SSL_SESSION");
            }

            str = rb_str_new(0, len);
            p = (unsigned char *)RSTRING_PTR(str);
            i2d_SSL_SESSION(ctx, &p);
            ossl_str_adjust(str, p);
            return str;
    }

to_pem → String click to toggle source

Returns a PEM encoded String that contains the Session object.

                   static VALUE ossl_ssl_session_to_pem(VALUE self)
    {
            SSL_SESSION *ctx;
            BIO *out;
            BUF_MEM *buf;
            VALUE str;
            int i;

            GetSSLSession(self, ctx);

            if (!(out = BIO_new(BIO_s_mem()))) {
                    ossl_raise(eSSLSession, "BIO_s_mem()");
            }

            if (!(i=PEM_write_bio_SSL_SESSION(out, ctx))) {
                    BIO_free(out);
                    ossl_raise(eSSLSession, "SSL_SESSION_print()");
            }

            BIO_get_mem_ptr(out, &buf);
            str = rb_str_new(buf->data, buf->length);
            BIO_free(out);

            return str;
    }

to_text → String click to toggle source

Shows everything in the Session object.

                   static VALUE ossl_ssl_session_to_text(VALUE self)
    {
            SSL_SESSION *ctx;
            BIO *out;
            BUF_MEM *buf;
            VALUE str;

            GetSSLSession(self, ctx);

            if (!(out = BIO_new(BIO_s_mem()))) {
                    ossl_raise(eSSLSession, "BIO_s_mem()");
            }

            if (!SSL_SESSION_print(out, ctx)) {
                    BIO_free(out);
                    ossl_raise(eSSLSession, "SSL_SESSION_print()");
            }

            BIO_get_mem_ptr(out, &buf);
            str = rb_str_new(buf->data, buf->length);
            BIO_free(out);

            return str;
    }