class axl::io::Ssl

#include <axl_io_Ssl.h>

class Ssl: public axl::sl::Handle
{
public:
    // methods

    bool
    create(SSL_CTX* ctx);

    int
    getError(int retCode);

    void
    setError(int retCode);

    void
    setBio(BIO* bio);

    void
    setBio(
        BIO* rbio,
        BIO* wbio
        );

    long
    getOptions();

    long
    setOptions(long options);

    long
    clearOptions(long options);

    void
    setInfoCallback(SslInfoCallbackFunc* callbackFunc);

    long
    getVerifyResult();

    int
    getVerifyDepth();

    void
    setVerifyDepth(int depth);

    int
    getVerifyMode();

    void
    setVerifyMode(int mode);

    void
    setVerify(
        int mode,
        SslVerifyCallbackFunc* callbackFunc
        );

    bool
    setTmpDh(DH* dh);

    void
    setTmpDhCallback(SslTmpDhCallbackFunc* callback);

    bool
    setTmpEcdh(EC_KEY* ec);

    STACK_OF(SSL_CIPHER);

    const char*
    getCipherName(int priority);

    bool
    setCipherList(const sl::StringRef& listString);

    void
    setConnectState();

    void
    setAcceptState();

    bool
    getReadAhead();

    void
    setReadAhead(bool isReadAhead);

    int
    getState();

    const char*
    getStateString();

    const char*
    getStateStringLong();

    const char*
    getCurrentCipherName();

    sl::String
    getCurrentCipherDescription();

    int
    getCurrentCipherBits();

    void*
    getExtraData(int index);

    bool
    setExtraData(
        int index,
        void* p
        );

    X509*
    getCertificate() const;

    bool
    useCertificate(const X509* cert);

    bool
    useCertificateFile(
        const sl::StringRef& fileName,
        int fileType = SSL_FILETYPE_PEM
        );

    EVP_PKEY*
    getPrivateKey() const;

    bool
    usePrivateKey(const EVP_PKEY* key);

    bool
    usePrivateKeyFile(
        const sl::StringRef& fileName,
        int fileType = SSL_FILETYPE_PEM
        );

    X509*
    getPeerCertificate() const;

    STACK_OF(X509) const;

    bool
    doHandshake();

    bool
    shutdown();

    size_t
    read(
        void* p,
        size_t size
        );

    size_t
    write(
        const void* p,
        size_t size
        );

    size_t
    getPendingReadSize();
};

Inherited Members

public:
    // typedefs

    typedef T H;

    // methods

    operator T() const;

    T
    operator->() const;

    const Handle&
    operator=(T h);

    bool
    isOpen() const;

    void
    close();

    void
    attach(T h);

    T
    detach();

    T*
    p();

    static
    T
    getInvalidHandle();