csocket_openssl.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef CSOCKET_OPENSSL_H
#define CSOCKET_OPENSSL_H

#include <set>
#include <list>
#include <bitset>
#include <stdio.h>

#include <openssl/bio.h>
#include <openssl/ssl.h>
#include <openssl/err.h>

#include "rofl/common/ciosrv.h"
#include "rofl/common/csocket.h"
#include "rofl/common/csocket_plain.h"
#include "rofl/common/logging.h"
#include "rofl/common/croflexception.h"

namespace rofl {

class eOpenSSL          : public        RoflException {
        std::string error;
public:
        eOpenSSL(std::string const& error) : error(error) {};
        virtual ~eOpenSSL() throw() {};
        friend std::ostream& operator<< (std::ostream& os, eOpenSSL const& e) {
                os << "<eOpenSSL error: " << e.error << " >" << std::endl;
                return os;
        };
};

class eOpenSSLVerify            : public eOpenSSL {};


class csocket_openssl :
        public csocket,
        public csocket_env
{
        //Defaults
        static std::string const        PARAM_DEFAULT_VALUE_SSL_KEY_CA_PATH;
        static std::string const        PARAM_DEFAULT_VALUE_SSL_KEY_CA_FILE;
        static std::string const        PARAM_DEFAULT_VALUE_SSL_KEY_CERT;
        static std::string const        PARAM_DEFAULT_VALUE_SSL_KEY_PRIVATE_KEY;
        static std::string const        PARAM_DEFAULT_VALUE_SSL_KEY_PRIVATE_KEY_PASSWORD;
        static std::string const        PARAM_DEFAULT_VALUE_SSL_KEY_VERIFY_MODE;
        static std::string const        PARAM_DEFAULT_VALUE_SSL_KEY_VERIFY_DEPTH;
        static std::string const        PARAM_DEFAULT_VALUE_SSL_KEY_CIPHERS;


        static bool ssl_initialized;

        static void
        openssl_init();

        static int
        openssl_password_callback(char *buf, int size, int rwflag, void *userdata);

        static std::set<csocket_openssl*> openssl_sockets;

        csocket_plain                           socket;
        pthread_rwlock_t                        ssl_lock;       
        std::list<rofl::cmemory*>       txqueue;

        enum openssl_event_t {
                EVENT_SEND_TXQUEUE              = 0,
                EVENT_RECV_RXQUEUE              = 1,
                EVENT_CONN_RESET                = 2,
        };

        /*
         * OpenSSL related structures
         */
        SSL_CTX                                         *ctx;
        SSL                                                     *ssl;
        BIO                                                     *bio;

        /*
         * socket parameters
         */
        std::string                                     capath;
        std::string                                     cafile;
        std::string                                     certfile;
        std::string                             keyfile;
        std::string                                     password;
        std::string                                     verify_mode;
        std::string                                     verify_depth;
        std::string                                     ciphers;

        enum openssl_flag_t {
                FLAG_SSL_IDLE                   = 0,
                FLAG_SSL_CONNECTING             = 1,
                FLAG_SSL_ACCEPTING              = 2,
                FLAG_SSL_ESTABLISHED    = 3,
                FLAG_SSL_CLOSING                = 4,
                FLAG_ACTIVE_SOCKET              = 5,
        };

        std::bitset<64>                         socket_flags;

public:



        csocket_openssl(csocket_env *owner);




        virtual
        ~csocket_openssl();


        virtual void
        listen(
                cparams const& params);


        virtual void
        accept(
                cparams const& socket_params, int sd);



        virtual void
        connect(
                cparams const& params);


        virtual void
        reconnect();


        virtual void
        close();


        virtual ssize_t
        recv(void *buf, size_t count);
        virtual ssize_t
        recv(void *buf, size_t count, int flags, rofl::csockaddr& from) {
                return recv(buf, count); // TODO: OpenSSL with DTLS on datagram sockets
        };


        virtual void
        send(cmemory *mem, csockaddr const& dest = csockaddr());


        virtual bool
        is_established() const { return socket_flags.test(FLAG_SSL_ESTABLISHED); };

        virtual bool
        write_would_block() const { return socket.write_would_block(); };

        static cparams
        get_default_params();


public:

        void
        set_capath(std::string const& capath) { this->capath = capath; };

        std::string const&
        get_capath() const { return capath; };

        void
        set_cafile(std::string const& cafile) { this->cafile = cafile; };

        std::string const&
        get_cafile() const { return cafile; };

        void
        set_certfile(std::string const& certfile) { this->certfile = certfile; };

        std::string const&
        get_certfile() const { return certfile; };

        void
        set_keyfile(std::string const& keyfile) { this->keyfile = keyfile; };

        std::string const&
        get_keyfile() const { return keyfile; };

        void
        set_password(std::string const& password) { this->password = password; };

        std::string const&
        get_password() const { return password; };





protected:

        //
        // socket specific methods, must be overloaded in derived class
        //

        virtual void
        handle_accepted(rofl::csocket& socket);

        virtual void
        handle_accept_refused(rofl::csocket& socket);

        virtual void
        handle_connected(rofl::csocket& socket);

        virtual void
        handle_connect_refused(rofl::csocket& socket);

        virtual void
        handle_connect_failed(rofl::csocket& socket);

        virtual void
        handle_listen(
                        rofl::csocket& socket,
                        int newsd);

        virtual void
        handle_closed(rofl::csocket& socket);

        virtual void
        handle_read(rofl::csocket& socket);

        virtual void
        handle_write(rofl::csocket& socket);



private:

        virtual void
        handle_event(cevent const& ev);

        void
        openssl_init_ctx();

        void
        openssl_destroy_ctx();

        void
        openssl_init_ssl();

        void
        openssl_destroy_ssl();

        void
        openssl_connect();

        void
        openssl_accept();

        bool
        openssl_verify_ok();


protected:


        virtual void
        dequeue_packet();


public:

        friend std::ostream&
        operator<< (std::ostream& os, csocket_openssl const& sock) {
                os << rofl::indent(0) << "<csocket_openssl >" << std::endl;
                os << rofl::indent(2) << "<flags: ";
                if (sock.socket_flags.test(FLAG_SSL_IDLE)) {
                        os << "IDLE ";
                }
                if (sock.socket_flags.test(FLAG_SSL_CONNECTING)) {
                        os << "CONNECTING ";
                }
                if (sock.socket_flags.test(FLAG_SSL_ACCEPTING)) {
                        os << "ACCEPTING ";
                }
                if (sock.socket_flags.test(FLAG_SSL_ESTABLISHED)) {
                        os << "ESTABLISHED ";
                }
                if (sock.socket_flags.test(FLAG_SSL_CLOSING)) {
                        os << "CLOSING ";
                }
                os << ">" << std::endl;
                rofl::indent i(2);
                os << sock.socket;
                return os;
        };

};

}; // end of namespace

#endif